chore: No ALL_CAPS (#1760)

Fixes #1680

tests/unit/etlng/ExtractionTests.cpp

@@ -40,7 +40,7 @@
 #include <optional>
 
 namespace {
-constinit auto const Seq = 30;
+constinit auto const kSEQ = 30;
 }  // namespace
 
 struct ExtractionTests : NoLoggerFixture {};
@@ -60,15 +60,15 @@ TEST_F(ExtractionTests, OneTransaction)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER);
+    auto expected = util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER);
 
     auto original = org::xrpl::rpc::v1::TransactionAndMetadata();
-    auto [metaRaw, txRaw] = util::CreateNftTxAndMetaBlobs();
+    auto [metaRaw, txRaw] = util::createNftTxAndMetaBlobs();
     original.set_transaction_blob(txRaw);
     original.set_metadata_blob(metaRaw);
 
-    auto res = extractTx(original, Seq);
-    EXPECT_EQ(res.meta.getLgrSeq(), Seq);
+    auto res = extractTx(original, kSEQ);
+    EXPECT_EQ(res.meta.getLgrSeq(), kSEQ);
     EXPECT_EQ(res.meta.getLgrSeq(), expected.meta.getLgrSeq());
     EXPECT_EQ(res.meta.getTxID(), expected.meta.getTxID());
     EXPECT_EQ(res.sttx.getTxnType(), expected.sttx.getTxnType());
@@ -78,10 +78,10 @@ TEST_F(ExtractionTests, MultipleTransactions)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER);
+    auto expected = util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER);
 
     auto original = org::xrpl::rpc::v1::TransactionAndMetadata();
-    auto [metaRaw, txRaw] = util::CreateNftTxAndMetaBlobs();
+    auto [metaRaw, txRaw] = util::createNftTxAndMetaBlobs();
     original.set_transaction_blob(txRaw);
     original.set_metadata_blob(metaRaw);
 
@@ -91,11 +91,11 @@ TEST_F(ExtractionTests, MultipleTransactions)
         *p = original;
     }
 
-    auto res = extractTxs(list.transactions(), Seq);
+    auto res = extractTxs(list.transactions(), kSEQ);
     EXPECT_EQ(res.size(), 10);
 
     for (auto const& tx : res) {
-        EXPECT_EQ(tx.meta.getLgrSeq(), Seq);
+        EXPECT_EQ(tx.meta.getLgrSeq(), kSEQ);
         EXPECT_EQ(tx.meta.getLgrSeq(), expected.meta.getLgrSeq());
         EXPECT_EQ(tx.meta.getTxID(), expected.meta.getTxID());
         EXPECT_EQ(tx.sttx.getTxnType(), expected.sttx.getTxnType());
@@ -106,7 +106,7 @@ TEST_F(ExtractionTests, OneObject)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateObject();
+    auto expected = util::createObject();
     auto original = org::xrpl::rpc::v1::RawLedgerObject();
     original.set_data(expected.dataRaw);
     original.set_key(expected.keyRaw);
@@ -114,8 +114,8 @@ TEST_F(ExtractionTests, OneObject)
     auto res = extractObj(original);
     EXPECT_EQ(ripple::strHex(res.key), ripple::strHex(expected.keyRaw));
     EXPECT_EQ(ripple::strHex(res.data), ripple::strHex(expected.dataRaw));
-    EXPECT_EQ(res.predecessor, uint256ToString(data::lastKey));
-    EXPECT_EQ(res.successor, uint256ToString(data::firstKey));
+    EXPECT_EQ(res.predecessor, uint256ToString(data::kLAST_KEY));
+    EXPECT_EQ(res.successor, uint256ToString(data::kFIRST_KEY));
     EXPECT_EQ(res.type, expected.type);
 }
 
@@ -123,7 +123,7 @@ TEST_F(ExtractionTests, OneObjectWithSuccessorAndPredecessor)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateObject();
+    auto expected = util::createObject();
     auto original = org::xrpl::rpc::v1::RawLedgerObject();
     original.set_data(expected.dataRaw);
     original.set_key(expected.keyRaw);
@@ -142,7 +142,7 @@ TEST_F(ExtractionTests, MultipleObjects)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateObject();
+    auto expected = util::createObject();
     auto original = org::xrpl::rpc::v1::RawLedgerObject();
     original.set_data(expected.dataRaw);
     original.set_key(expected.keyRaw);
@@ -159,8 +159,8 @@ TEST_F(ExtractionTests, MultipleObjects)
     for (auto const& obj : res) {
         EXPECT_EQ(ripple::strHex(obj.key), ripple::strHex(expected.keyRaw));
         EXPECT_EQ(ripple::strHex(obj.data), ripple::strHex(expected.dataRaw));
-        EXPECT_EQ(obj.predecessor, uint256ToString(data::lastKey));
-        EXPECT_EQ(obj.successor, uint256ToString(data::firstKey));
+        EXPECT_EQ(obj.predecessor, uint256ToString(data::kLAST_KEY));
+        EXPECT_EQ(obj.successor, uint256ToString(data::kFIRST_KEY));
         EXPECT_EQ(obj.type, expected.type);
     }
 }
@@ -169,7 +169,7 @@ TEST_F(ExtractionTests, OneSuccessor)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateSuccessor();
+    auto expected = util::createSuccessor();
     auto original = org::xrpl::rpc::v1::BookSuccessor();
     original.set_first_book(expected.firstBook);
     original.set_book_base(expected.bookBase);
@@ -183,7 +183,7 @@ TEST_F(ExtractionTests, MultipleSuccessors)
 {
     using namespace etlng::impl;
 
-    auto expected = util::CreateSuccessor();
+    auto expected = util::createSuccessor();
     auto original = org::xrpl::rpc::v1::BookSuccessor();
     original.set_first_book(expected.firstBook);
     original.set_book_base(expected.bookBase);
@@ -245,24 +245,24 @@ struct ExtractorTests : ExtractionTests {
 
 TEST_F(ExtractorTests, ExtractLedgerWithDiffNoResult)
 {
-    EXPECT_CALL(*fetcher, fetchDataAndDiff(Seq)).WillOnce(testing::Return(std::nullopt));
-    auto res = extractor.extractLedgerWithDiff(Seq);
+    EXPECT_CALL(*fetcher, fetchDataAndDiff(kSEQ)).WillOnce(testing::Return(std::nullopt));
+    auto res = extractor.extractLedgerWithDiff(kSEQ);
     EXPECT_FALSE(res.has_value());
 }
 
 TEST_F(ExtractorTests, ExtractLedgerOnlyNoResult)
 {
-    EXPECT_CALL(*fetcher, fetchData(Seq)).WillOnce(testing::Return(std::nullopt));
-    auto res = extractor.extractLedgerOnly(Seq);
+    EXPECT_CALL(*fetcher, fetchData(kSEQ)).WillOnce(testing::Return(std::nullopt));
+    auto res = extractor.extractLedgerOnly(kSEQ);
     EXPECT_FALSE(res.has_value());
 }
 
 TEST_F(ExtractorTests, ExtractLedgerWithDiffWithResult)
 {
-    auto original = util::CreateDataAndDiff();
+    auto original = util::createDataAndDiff();
 
-    EXPECT_CALL(*fetcher, fetchDataAndDiff(Seq)).WillOnce(testing::Return(original));
-    auto res = extractor.extractLedgerWithDiff(Seq);
+    EXPECT_CALL(*fetcher, fetchDataAndDiff(kSEQ)).WillOnce(testing::Return(original));
+    auto res = extractor.extractLedgerWithDiff(kSEQ);
 
     EXPECT_TRUE(res.has_value());
     EXPECT_EQ(res->objects.size(), 10);
@@ -274,10 +274,10 @@ TEST_F(ExtractorTests, ExtractLedgerWithDiffWithResult)
 
 TEST_F(ExtractorTests, ExtractLedgerOnlyWithResult)
 {
-    auto original = util::CreateData();
+    auto original = util::createData();
 
-    EXPECT_CALL(*fetcher, fetchData(Seq)).WillOnce(testing::Return(original));
-    auto res = extractor.extractLedgerOnly(Seq);
+    EXPECT_CALL(*fetcher, fetchData(kSEQ)).WillOnce(testing::Return(original));
+    auto res = extractor.extractLedgerOnly(kSEQ);
 
     EXPECT_TRUE(res.has_value());
     EXPECT_TRUE(res->objects.empty());

tests/unit/etlng/GrpcSourceTests.cpp

@@ -124,11 +124,13 @@ struct GrpcSourceNgTests : NoLoggerFixture, tests::util::WithMockXrpLedgerAPISer
         };
     };
 
+protected:
     testing::StrictMock<MockLoadObserver> observer_;
     etlng::impl::GrpcSource grpcSource_;
 };
 
 struct GrpcSourceNgLoadInitialLedgerTests : GrpcSourceNgTests {
+protected:
     uint32_t const sequence_ = 123u;
     uint32_t const numMarkers_ = 4u;
     bool const cacheOnly_ = false;
@@ -189,7 +191,7 @@ TEST_F(GrpcSourceNgLoadInitialLedgerTests, ObserverCalledCorrectly)
 {
     auto const key = ripple::uint256{4};
     auto const keyStr = uint256ToString(key);
-    auto const object = CreateTicketLedgerObject("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", sequence_);
+    auto const object = createTicketLedgerObject("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", sequence_);
     auto const objectData = object.getSerializer().peekData();
 
     EXPECT_CALL(mockXrpLedgerAPIService, GetLedgerData)
@@ -232,7 +234,7 @@ TEST_F(GrpcSourceNgLoadInitialLedgerTests, DataTransferredAndObserverCalledCorre
 
     auto keyStore = KeyStore(totalKeys, numMarkers_);
 
-    auto const object = CreateTicketLedgerObject("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", sequence_);
+    auto const object = createTicketLedgerObject("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", sequence_);
     auto const objectData = object.getSerializer().peekData();
 
     EXPECT_CALL(mockXrpLedgerAPIService, GetLedgerData)

tests/unit/etlng/RegistryTests.cpp

@@ -127,8 +127,8 @@ static_assert(ContainsSpec<ValidSpec>);
 
 namespace {
 
-constinit auto const LedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
-constinit auto const Seq = 30;
+constinit auto const kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
+constinit auto const kSEQ = 30;
 
 struct MockExtLedgerData {
     MOCK_METHOD(void, onLedgerData, (etlng::model::LedgerData const&), (const));
@@ -183,9 +183,9 @@ struct RegistryTest : NoLoggerFixture {};
 TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForInitialTransaction)
 {
     auto transactions = std::vector{
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
     };
 
     auto extBurn = MockExtNftBurn{};
@@ -194,7 +194,7 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForInitialTransaction)
     EXPECT_CALL(extBurn, onInitialTransaction(testing::_, testing::_)).Times(2);  // 2 burn txs
     EXPECT_CALL(extOffer, onInitialTransaction(testing::_, testing::_));          // 1 create offer
 
-    auto const header = CreateLedgerHeader(LedgerHash, Seq);
+    auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ);
     auto reg = Registry<MockExtNftBurn&, MockExtNftOffer&>(extBurn, extOffer);
     reg.dispatchInitialData(etlng::model::LedgerData{
         .transactions = transactions,
@@ -203,16 +203,16 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForInitialTransaction)
         .edgeKeys = {},
         .header = header,
         .rawHeader = {},
-        .seq = Seq,
+        .seq = kSEQ,
     });
 }
 
 TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForTransaction)
 {
     auto transactions = std::vector{
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
     };
 
     auto extBurn = MockExtTransactionNftBurn{};
@@ -221,7 +221,7 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForTransaction)
     EXPECT_CALL(extBurn, onTransaction(testing::_, testing::_)).Times(2);  // 2 burn txs
     EXPECT_CALL(extOffer, onTransaction(testing::_, testing::_));          // 1 create offer
 
-    auto const header = CreateLedgerHeader(LedgerHash, Seq);
+    auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ);
     auto reg = Registry<MockExtTransactionNftBurn&, MockExtTransactionNftOffer&>(extBurn, extOffer);
     reg.dispatch(etlng::model::LedgerData{
         .transactions = std::move(transactions),
@@ -230,7 +230,7 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForTransaction)
         .edgeKeys = {},
         .header = header,
         .rawHeader = {},
-        .seq = Seq
+        .seq = kSEQ
     });
 }
 
@@ -243,7 +243,7 @@ TEST_F(RegistryTest, InitialObjectsEmpty)
     EXPECT_CALL(extObjs, onInitialObjects(testing::_, testing::_, testing::_));  // 1 vector passed as is
 
     auto reg = Registry<MockExtInitialObject&, MockExtInitialObjects&>(extObj, extObjs);
-    reg.dispatchInitialObjects(Seq, {}, {});
+    reg.dispatchInitialObjects(kSEQ, {}, {});
 }
 
 TEST_F(RegistryTest, InitialObjectsDispatched)
@@ -255,7 +255,7 @@ TEST_F(RegistryTest, InitialObjectsDispatched)
     EXPECT_CALL(extObjs, onInitialObjects(testing::_, testing::_, testing::_));  // 1 vector passed as is
 
     auto reg = Registry<MockExtInitialObject&, MockExtInitialObjects&>(extObj, extObjs);
-    reg.dispatchInitialObjects(Seq, {util::CreateObject(), util::CreateObject(), util::CreateObject()}, {});
+    reg.dispatchInitialObjects(kSEQ, {util::createObject(), util::createObject(), util::createObject()}, {});
 }
 
 TEST_F(RegistryTest, ObjectsDispatched)
@@ -264,32 +264,32 @@ TEST_F(RegistryTest, ObjectsDispatched)
 
     EXPECT_CALL(extObj, onObject(testing::_, testing::_)).Times(3);  // 3 objects sent
 
-    auto const header = CreateLedgerHeader(LedgerHash, Seq);
+    auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ);
     auto reg = Registry<MockExtOnObject&>(extObj);
     reg.dispatch(etlng::model::LedgerData{
         .transactions = {},
-        .objects = {util::CreateObject(), util::CreateObject(), util::CreateObject()},
+        .objects = {util::createObject(), util::createObject(), util::createObject()},
         .successors = {},
         .edgeKeys = {},
         .header = header,
         .rawHeader = {},
-        .seq = Seq
+        .seq = kSEQ
     });
 }
 
 TEST_F(RegistryTest, OnLedgerDataForBatch)
 {
     auto transactions = std::vector{
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
     };
 
     auto ext = MockExtLedgerData{};
 
     EXPECT_CALL(ext, onLedgerData(testing::_));  // 1 batch (dispatch call)
 
-    auto const header = CreateLedgerHeader(LedgerHash, Seq);
+    auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ);
     auto reg = Registry<MockExtLedgerData&>(ext);
     reg.dispatch(etlng::model::LedgerData{
         .transactions = std::move(transactions),
@@ -298,7 +298,7 @@ TEST_F(RegistryTest, OnLedgerDataForBatch)
         .edgeKeys = {},
         .header = header,
         .rawHeader = {},
-        .seq = Seq
+        .seq = kSEQ
     });
 }
 
@@ -312,7 +312,7 @@ TEST_F(RegistryTest, InitialObjectsCorrectOrderOfHookCalls)
     EXPECT_CALL(extObj, onInitialObject).Times(3);
 
     auto reg = Registry<MockExtInitialObject&, MockExtInitialObjects&>(extObj, extObjs);
-    reg.dispatchInitialObjects(Seq, {util::CreateObject(), util::CreateObject(), util::CreateObject()}, {});
+    reg.dispatchInitialObjects(kSEQ, {util::createObject(), util::createObject(), util::createObject()}, {});
 }
 
 TEST_F(RegistryTest, InitialDataCorrectOrderOfHookCalls)
@@ -321,16 +321,16 @@ TEST_F(RegistryTest, InitialDataCorrectOrderOfHookCalls)
     auto extInitialTransaction = MockExtNftBurn{};
 
     auto transactions = std::vector{
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
     };
 
     testing::InSequence const seqGuard;
     EXPECT_CALL(extInitialData, onInitialData);
     EXPECT_CALL(extInitialTransaction, onInitialTransaction).Times(2);
 
-    auto const header = CreateLedgerHeader(LedgerHash, Seq);
+    auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ);
     auto reg = Registry<MockExtNftBurn&, MockExtInitialData&>(extInitialTransaction, extInitialData);
     reg.dispatchInitialData(etlng::model::LedgerData{
         .transactions = std::move(transactions),
@@ -339,7 +339,7 @@ TEST_F(RegistryTest, InitialDataCorrectOrderOfHookCalls)
         .edgeKeys = {},
         .header = header,
         .rawHeader = {},
-        .seq = Seq
+        .seq = kSEQ
     });
 }
 
@@ -350,14 +350,14 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls)
     auto extOnObject = MockExtOnObject{};
 
     auto transactions = std::vector{
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_BURN),
-        util::CreateTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_BURN),
+        util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER),
     };
     auto objects = std::vector{
-        util::CreateObject(),
-        util::CreateObject(),
-        util::CreateObject(),
+        util::createObject(),
+        util::createObject(),
+        util::createObject(),
     };
 
     // testing::Sequence seq;
@@ -366,7 +366,7 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls)
     EXPECT_CALL(extOnTransaction, onTransaction).Times(2);
     EXPECT_CALL(extOnObject, onObject).Times(3);
 
-    auto const header = CreateLedgerHeader(LedgerHash, Seq);
+    auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ);
     auto reg = Registry<MockExtOnObject&, MockExtTransactionNftBurn&, MockExtLedgerData&>(
         extOnObject, extOnTransaction, extLedgerData
     );
@@ -377,6 +377,6 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls)
         .edgeKeys = {},
         .header = header,
         .rawHeader = {},
-        .seq = Seq
+        .seq = kSEQ
     });
 }