diff --git a/.clang-tidy b/.clang-tidy index 069b62dc6..4f4405224 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -169,7 +169,7 @@ CheckOptions: readability-identifier-naming.EnumCase: CamelCase readability-identifier-naming.EnumConstantCase: CamelCase readability-identifier-naming.ScopedEnumConstantCase: CamelCase - readability-identifier-naming.GlobalConstantCase: UPPER_CASE + readability-identifier-naming.GlobalConstantCase: CamelCase readability-identifier-naming.GlobalConstantPrefix: "k" readability-identifier-naming.GlobalVariableCase: CamelCase readability-identifier-naming.GlobalVariablePrefix: "g" @@ -177,14 +177,12 @@ CheckOptions: readability-identifier-naming.ConstexprMethodCase: camelBack readability-identifier-naming.ClassMethodCase: camelBack readability-identifier-naming.ClassMemberCase: camelBack - readability-identifier-naming.ClassConstantCase: UPPER_CASE + readability-identifier-naming.ClassConstantCase: CamelCase readability-identifier-naming.ClassConstantPrefix: "k" - readability-identifier-naming.StaticConstantCase: UPPER_CASE + readability-identifier-naming.StaticConstantCase: CamelCase readability-identifier-naming.StaticConstantPrefix: "k" - readability-identifier-naming.StaticVariableCase: UPPER_CASE - readability-identifier-naming.StaticVariablePrefix: "k" - readability-identifier-naming.ConstexprVariableCase: UPPER_CASE - readability-identifier-naming.ConstexprVariablePrefix: "k" + readability-identifier-naming.StaticVariableCase: camelBack + readability-identifier-naming.ConstexprVariableCase: camelBack readability-identifier-naming.LocalConstantCase: camelBack readability-identifier-naming.LocalVariableCase: camelBack readability-identifier-naming.TemplateParameterCase: CamelCase diff --git a/benchmarks/rpc/WorkQueueBenchmarks.cpp b/benchmarks/rpc/WorkQueueBenchmarks.cpp index 854ce8255..632ed4404 100644 --- a/benchmarks/rpc/WorkQueueBenchmarks.cpp +++ b/benchmarks/rpc/WorkQueueBenchmarks.cpp @@ -26,7 +26,7 @@ using namespace util::config; namespace { -auto const kCONFIG = ClioConfigDefinition{ +auto const kConfig = ClioConfigDefinition{ {"prometheus.compress_reply", ConfigValue{ConfigType::Boolean}.defaultValue(true)}, {"prometheus.enabled", ConfigValue{ConfigType::Boolean}.defaultValue(true)}, {"log.channels.[].channel", Array{ConfigValue{ConfigType::String}}}, @@ -48,10 +48,10 @@ auto const kCONFIG = ClioConfigDefinition{ void init() { - static std::once_flag kONCE; - std::call_once(kONCE, [] { - PrometheusService::init(kCONFIG); - (void)util::LogService::init(kCONFIG); + static std::once_flag kOnce; + std::call_once(kOnce, [] { + PrometheusService::init(kConfig); + (void)util::LogService::init(kConfig); }); } diff --git a/benchmarks/util/async/ExecutionContextBenchmarks.cpp b/benchmarks/util/async/ExecutionContextBenchmarks.cpp index fa93f3d16..90e052649 100644 --- a/benchmarks/util/async/ExecutionContextBenchmarks.cpp +++ b/benchmarks/util/async/ExecutionContextBenchmarks.cpp @@ -169,11 +169,11 @@ public: static auto generateData() { - constexpr auto kTOTAL = 10'000; + constexpr auto kTotal = 10'000; std::vector data; - data.reserve(kTOTAL); + data.reserve(kTotal); util::MTRandomGenerator randomGenerator; - for (auto i = 0; i < kTOTAL; ++i) + for (auto i = 0; i < kTotal; ++i) data.push_back(randomGenerator.uniform(1, 100'000'000)); return data; diff --git a/benchmarks/util/log/LoggerBenchmark.cpp b/benchmarks/util/log/LoggerBenchmark.cpp index e175bf7ce..b8a519cdc 100644 --- a/benchmarks/util/log/LoggerBenchmark.cpp +++ b/benchmarks/util/log/LoggerBenchmark.cpp @@ -21,7 +21,7 @@ using namespace util; -static constexpr auto kLOG_FORMAT = "%Y-%m-%d %H:%M:%S.%f %^%3!l:%n%$ - %v"; +static constexpr auto kLogFormat = "%Y-%m-%d %H:%M:%S.%f %^%3!l:%n%$ - %v"; struct BenchmarkLoggingInitializer { [[nodiscard]] static std::shared_ptr @@ -32,7 +32,7 @@ struct BenchmarkLoggingInitializer { .logDir = logDir, .rotation = LogService::RotationParams{.sizeMB = sizeMB, .maxFiles = maxFiles}, }, - kLOG_FORMAT + kLogFormat ); } @@ -71,9 +71,9 @@ benchmarkConcurrentFileLogging(benchmark::State& state) state.PauseTiming(); std::filesystem::create_directories(logDir); - static constexpr size_t kQUEUE_SIZE = 8192; - static constexpr size_t kTHREAD_COUNT = 1; - spdlog::init_thread_pool(kQUEUE_SIZE, kTHREAD_COUNT); + static constexpr size_t kQueueSize = 8192; + static constexpr size_t kThreadCount = 1; + spdlog::init_thread_pool(kQueueSize, kThreadCount); auto fileSink = BenchmarkLoggingInitializer::createFileSink(logDir, 5, 25); diff --git a/src/app/CliArgs.cpp b/src/app/CliArgs.cpp index 8be2da557..379ae3853 100644 --- a/src/app/CliArgs.cpp +++ b/src/app/CliArgs.cpp @@ -28,7 +28,7 @@ CliArgs::parse(int argc, char const* argv[]) description.add_options() ("help,h", "Print help message and exit") ("version,v", "Print version and exit") - ("conf,c", po::value()->default_value(kDEFAULT_CONFIG_PATH), "Configuration file") + ("conf,c", po::value()->default_value(kDefaultConfigPath), "Configuration file") ("ng-web-server,w", "Use ng-web-server") ("migrate", po::value(), "Start migration helper") ("verify", "Checks the validity of config values") diff --git a/src/app/CliArgs.hpp b/src/app/CliArgs.hpp index 0f0c98499..5873447fb 100644 --- a/src/app/CliArgs.hpp +++ b/src/app/CliArgs.hpp @@ -16,7 +16,7 @@ public: /** * @brief Default configuration path. */ - static constexpr char kDEFAULT_CONFIG_PATH[] = "/etc/opt/clio/config.json"; + static constexpr char kDefaultConfigPath[] = "/etc/opt/clio/config.json"; /** * @brief An action parsed from the command line. diff --git a/src/app/WebHandlers.cpp b/src/app/WebHandlers.cpp index 9c895891e..ccc9490d4 100644 --- a/src/app/WebHandlers.cpp +++ b/src/app/WebHandlers.cpp @@ -125,7 +125,7 @@ HealthCheckHandler::operator()( boost::asio::yield_context ) { - static constexpr auto kHEALTH_CHECK_HTML = R"html( + static constexpr auto kHealthCheckHtml = R"html( Test page for Clio @@ -133,7 +133,7 @@ HealthCheckHandler::operator()( )html"; - return web::ng::Response{boost::beast::http::status::ok, kHEALTH_CHECK_HTML, request}; + return web::ng::Response{boost::beast::http::status::ok, kHealthCheckHtml, request}; } web::ng::Response @@ -144,7 +144,7 @@ CacheStateHandler::operator()( boost::asio::yield_context ) { - static constexpr auto kCACHE_CHECK_LOADED_HTML = R"html( + static constexpr auto kCacheCheckLoadedHtml = R"html( Cache state @@ -152,7 +152,7 @@ CacheStateHandler::operator()( )html"; - static constexpr auto kCACHE_CHECK_NOT_LOADED_HTML = R"html( + static constexpr auto kCacheCheckNotLoadedHtml = R"html( Cache state @@ -161,10 +161,10 @@ CacheStateHandler::operator()( )html"; if (cache_.get().isFull()) - return web::ng::Response{boost::beast::http::status::ok, kCACHE_CHECK_LOADED_HTML, request}; + return web::ng::Response{boost::beast::http::status::ok, kCacheCheckLoadedHtml, request}; return web::ng::Response{ - boost::beast::http::status::service_unavailable, kCACHE_CHECK_NOT_LOADED_HTML, request + boost::beast::http::status::service_unavailable, kCacheCheckNotLoadedHtml, request }; } diff --git a/src/cluster/ClioNode.cpp b/src/cluster/ClioNode.cpp index ab7b762d0..b12b5d6cb 100644 --- a/src/cluster/ClioNode.cpp +++ b/src/cluster/ClioNode.cpp @@ -22,12 +22,11 @@ namespace cluster { namespace { struct JsonFields { - static constexpr std::string_view const kUPDATE_TIME = "update_time"; - static constexpr std::string_view const kDB_ROLE = "db_role"; - static constexpr std::string_view const kETL_STARTED = "etl_started"; - static constexpr std::string_view const kCACHE_IS_FULL = "cache_is_full"; - static constexpr std::string_view const kCACHE_IS_CURRENTLY_LOADING = - "cache_is_currently_loading"; + static constexpr std::string_view const kUpdateTime = "update_time"; + static constexpr std::string_view const kDbRole = "db_role"; + static constexpr std::string_view const kEtlStarted = "etl_started"; + static constexpr std::string_view const kCacheIsFull = "cache_is_full"; + static constexpr std::string_view const kCacheIsCurrentlyLoading = "cache_is_currently_loading"; }; } // namespace @@ -67,11 +66,11 @@ void tag_invoke(boost::json::value_from_tag, boost::json::value& jv, ClioNode const& node) { jv = { - {JsonFields::kUPDATE_TIME, util::systemTpToUtcStr(node.updateTime, ClioNode::kTIME_FORMAT)}, - {JsonFields::kDB_ROLE, static_cast(node.dbRole)}, - {JsonFields::kETL_STARTED, node.etlStarted}, - {JsonFields::kCACHE_IS_FULL, node.cacheIsFull}, - {JsonFields::kCACHE_IS_CURRENTLY_LOADING, node.cacheIsCurrentlyLoading} + {JsonFields::kUpdateTime, util::systemTpToUtcStr(node.updateTime, ClioNode::kTimeFormat)}, + {JsonFields::kDbRole, static_cast(node.dbRole)}, + {JsonFields::kEtlStarted, node.etlStarted}, + {JsonFields::kCacheIsFull, node.cacheIsFull}, + {JsonFields::kCacheIsCurrentlyLoading, node.cacheIsCurrentlyLoading} }; } @@ -79,16 +78,16 @@ ClioNode tag_invoke(boost::json::value_to_tag, boost::json::value const& jv) { auto const& obj = jv.as_object(); - auto const& updateTimeStr = obj.at(JsonFields::kUPDATE_TIME).as_string(); + auto const& updateTimeStr = obj.at(JsonFields::kUpdateTime).as_string(); auto const updateTime = - util::systemTpFromUtcStr(std::string(updateTimeStr), ClioNode::kTIME_FORMAT); + util::systemTpFromUtcStr(std::string(updateTimeStr), ClioNode::kTimeFormat); if (!updateTime.has_value()) { throw std::runtime_error("Failed to parse update time"); } // Each field has a default value for backward compatibility auto dbRole = ClioNode::DbRole::Fallback; - if (auto const* v = obj.if_contains(JsonFields::kDB_ROLE)) { + if (auto const* v = obj.if_contains(JsonFields::kDbRole)) { auto const dbRoleValue = v->as_int64(); if (dbRoleValue > static_cast(ClioNode::DbRole::Max)) throw std::runtime_error("Invalid db_role value"); @@ -96,12 +95,11 @@ tag_invoke(boost::json::value_to_tag, boost::json::value const& jv) } auto const etlStarted = - obj.contains(JsonFields::kETL_STARTED) ? obj.at(JsonFields::kETL_STARTED).as_bool() : true; - auto const cacheIsFull = obj.contains(JsonFields::kCACHE_IS_FULL) - ? obj.at(JsonFields::kCACHE_IS_FULL).as_bool() - : true; - auto const cacheIsCurrentlyLoading = obj.contains(JsonFields::kCACHE_IS_CURRENTLY_LOADING) - ? obj.at(JsonFields::kCACHE_IS_CURRENTLY_LOADING).as_bool() + obj.contains(JsonFields::kEtlStarted) ? obj.at(JsonFields::kEtlStarted).as_bool() : true; + auto const cacheIsFull = + obj.contains(JsonFields::kCacheIsFull) ? obj.at(JsonFields::kCacheIsFull).as_bool() : true; + auto const cacheIsCurrentlyLoading = obj.contains(JsonFields::kCacheIsCurrentlyLoading) + ? obj.at(JsonFields::kCacheIsCurrentlyLoading).as_bool() : false; return ClioNode{ diff --git a/src/cluster/ClioNode.hpp b/src/cluster/ClioNode.hpp index 7bd36c34c..a74c4e7b4 100644 --- a/src/cluster/ClioNode.hpp +++ b/src/cluster/ClioNode.hpp @@ -19,7 +19,7 @@ struct ClioNode { /** * @brief The format of the time to store in the database. */ - static constexpr char const* kTIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"; + static constexpr char const* kTimeFormat = "%Y-%m-%dT%H:%M:%SZ"; /** * @brief Database role of a node in the cluster. diff --git a/src/cluster/ClusterCommunicationService.hpp b/src/cluster/ClusterCommunicationService.hpp index 052cbc355..685c73b56 100644 --- a/src/cluster/ClusterCommunicationService.hpp +++ b/src/cluster/ClusterCommunicationService.hpp @@ -36,8 +36,8 @@ class ClusterCommunicationService : public ClusterCommunicationServiceTag { CacheLoaderDecider cacheLoaderDecider_; public: - static constexpr std::chrono::milliseconds kDEFAULT_READ_INTERVAL{1000}; - static constexpr std::chrono::milliseconds kDEFAULT_WRITE_INTERVAL{1000}; + static constexpr std::chrono::milliseconds kDefaultReadInterval{1000}; + static constexpr std::chrono::milliseconds kDefaultWriteInterval{1000}; /** * @brief Construct a new Cluster Communication Service object. @@ -52,8 +52,8 @@ public: std::shared_ptr backend, std::unique_ptr writerState, std::unique_ptr cacheLoadingState, - std::chrono::steady_clock::duration readInterval = kDEFAULT_READ_INTERVAL, - std::chrono::steady_clock::duration writeInterval = kDEFAULT_WRITE_INTERVAL + std::chrono::steady_clock::duration readInterval = kDefaultReadInterval, + std::chrono::steady_clock::duration writeInterval = kDefaultWriteInterval ); ~ClusterCommunicationService() override; diff --git a/src/cluster/WriterDecider.hpp b/src/cluster/WriterDecider.hpp index cfbc38483..e65d7e18e 100644 --- a/src/cluster/WriterDecider.hpp +++ b/src/cluster/WriterDecider.hpp @@ -63,7 +63,7 @@ namespace cluster { */ class WriterDecider { public: - static constexpr std::chrono::steady_clock::duration kRECOVERY_TIME = std::chrono::hours{1}; + static constexpr std::chrono::steady_clock::duration kRecoveryTime = std::chrono::hours{1}; private: /** @brief Thread pool for spawning asynchronous tasks */ @@ -90,12 +90,12 @@ public: * @param ctx Thread pool for executing asynchronous operations * @param writerState Writer state interface for controlling write operations * @param recoveryTime How long to wait in Fallback before attempting recovery - * (defaults to `kRECOVERY_TIME`; pass a short duration in tests) + * (defaults to `kRecoveryTime`; pass a short duration in tests) */ WriterDecider( boost::asio::thread_pool& ctx, std::unique_ptr writerState, - std::chrono::steady_clock::duration recoveryTime = kRECOVERY_TIME + std::chrono::steady_clock::duration recoveryTime = kRecoveryTime ); /** diff --git a/src/data/AmendmentCenter.cpp b/src/data/AmendmentCenter.cpp index 2a3051c81..e3f94075c 100644 --- a/src/data/AmendmentCenter.cpp +++ b/src/data/AmendmentCenter.cpp @@ -33,8 +33,8 @@ namespace { std::unordered_set& supportedAmendments() { - static std::unordered_set kAMENDMENTS = {}; - return kAMENDMENTS; + static std::unordered_set kAmendments = {}; + return kAmendments; } bool diff --git a/src/data/BackendCounters.cpp b/src/data/BackendCounters.cpp index 8ce868e32..caed0253b 100644 --- a/src/data/BackendCounters.cpp +++ b/src/data/BackendCounters.cpp @@ -17,7 +17,7 @@ namespace data { namespace { -std::vector const kHISTOGRAM_BUCKETS{1, 2, 5, 10, 20, 50, 100, 200, 500, 700, 1000}; +std::vector const kHistogramBuckets{1, 2, 5, 10, 20, 50, 100, 200, 500, 700, 1000}; std::int64_t durationInMillisecondsSince(std::chrono::steady_clock::time_point const startTime) @@ -60,7 +60,7 @@ BackendCounters::BackendCounters() PrometheusService::histogramInt( "backend_duration_milliseconds_histogram", Labels({Label{"operation", "read"}}), - kHISTOGRAM_BUCKETS, + kHistogramBuckets, "The duration of backend read operations including retries" ) ) @@ -68,7 +68,7 @@ BackendCounters::BackendCounters() PrometheusService::histogramInt( "backend_duration_milliseconds_histogram", Labels({Label{"operation", "write"}}), - kHISTOGRAM_BUCKETS, + kHistogramBuckets, "The duration of backend write operations including retries" ) ) diff --git a/src/data/BackendInterface.cpp b/src/data/BackendInterface.cpp index a7cadee6f..7f84df262 100644 --- a/src/data/BackendInterface.cpp +++ b/src/data/BackendInterface.cpp @@ -311,7 +311,7 @@ BackendInterface::fetchLedgerPage( ripple::uint256 const& curCursor = [&]() { if (!keys.empty()) return keys.back(); - return (cursor ? *cursor : kFIRST_KEY); + return (cursor ? *cursor : kFirstKey); }(); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) diff --git a/src/data/BackendInterface.hpp b/src/data/BackendInterface.hpp index d677a2ee3..5c0bc05e0 100644 --- a/src/data/BackendInterface.hpp +++ b/src/data/BackendInterface.hpp @@ -49,7 +49,7 @@ public: } }; -static constexpr std::size_t kDEFAULT_WAIT_BETWEEN_RETRY = 500; +static constexpr std::size_t kDefaultWaitBetweenRetry = 500; /** * @brief A helper function that catches DatabaseTimeout exceptions and retries indefinitely. * @@ -60,7 +60,7 @@ static constexpr std::size_t kDEFAULT_WAIT_BETWEEN_RETRY = 500; */ template auto -retryOnTimeout(FnType func, size_t waitMs = kDEFAULT_WAIT_BETWEEN_RETRY) +retryOnTimeout(FnType func, size_t waitMs = kDefaultWaitBetweenRetry) { static util::Logger const log{"Backend"}; // NOLINT(readability-identifier-naming) diff --git a/src/data/DBHelpers.hpp b/src/data/DBHelpers.hpp index ee5c71c5f..7e1c42607 100644 --- a/src/data/DBHelpers.hpp +++ b/src/data/DBHelpers.hpp @@ -209,13 +209,13 @@ template inline bool isDirNode(T const& object) { - static constexpr auto kMIN_SIZE_REQUIRED = 3; - if (std::size(object) < kMIN_SIZE_REQUIRED) + static constexpr auto kMinSizeRequired = 3; + if (std::size(object) < kMinSizeRequired) return false; - static constexpr short kDIR_NODE_SPACE_KEY = 0x0064; + static constexpr short kDirNodeSpaceKey = 0x0064; short const spaceKey = (object.data()[1] << 8) | object.data()[2]; - return spaceKey == kDIR_NODE_SPACE_KEY; + return spaceKey == kDirNodeSpaceKey; } /** @@ -246,12 +246,12 @@ template inline ripple::uint256 getBookBase(T const& key) { - static constexpr size_t kEY_SIZE = 24; + static constexpr size_t kEySize = 24; ASSERT(key.size() == ripple::uint256::size(), "Invalid key size {}", key.size()); ripple::uint256 ret; - for (size_t i = 0; i < kEY_SIZE; ++i) + for (size_t i = 0; i < kEySize; ++i) ret.data()[i] = key.data()[i]; return ret; @@ -270,4 +270,4 @@ uint256ToString(ripple::uint256 const& input) } /** @brief The ripple epoch start timestamp. Midnight on 1st January 2000. */ -static constexpr std::uint32_t kRIPPLE_EPOCH_START = 946684800; +static constexpr std::uint32_t kRippleEpochStart = 946684800; diff --git a/src/data/Types.hpp b/src/data/Types.hpp index fa3ad7b7f..c7ed6d2cd 100644 --- a/src/data/Types.hpp +++ b/src/data/Types.hpp @@ -312,13 +312,13 @@ struct AmendmentKey { operator<=>(AmendmentKey const& other) const = default; }; -constexpr ripple::uint256 kFIRST_KEY{ +constexpr ripple::uint256 kFirstKey{ "0000000000000000000000000000000000000000000000000000000000000000" }; -constexpr ripple::uint256 kLAST_KEY{ +constexpr ripple::uint256 kLastKey{ "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" }; -constexpr ripple::uint256 kHI192{ +constexpr ripple::uint256 kHi192{ "0000000000000000000000000000000000000000000000001111111111111111" }; diff --git a/src/data/cassandra/CassandraBackendFamily.hpp b/src/data/cassandra/CassandraBackendFamily.hpp index 50166ac48..3d29998f5 100644 --- a/src/data/cassandra/CassandraBackendFamily.hpp +++ b/src/data/cassandra/CassandraBackendFamily.hpp @@ -603,7 +603,7 @@ public: if (auto const res = executor_.read(yield, schema_->selectSuccessor, key, ledgerSequence); res) { if (auto const result = res->template get(); result) { - if (*result == kLAST_KEY) + if (*result == kLastKey) return std::nullopt; return result; } diff --git a/src/data/cassandra/SettingsProvider.cpp b/src/data/cassandra/SettingsProvider.cpp index c9f461d96..d0f57eaa3 100644 --- a/src/data/cassandra/SettingsProvider.cpp +++ b/src/data/cassandra/SettingsProvider.cpp @@ -90,13 +90,13 @@ SettingsProvider::parseSettings() const if (config_.getValueView("connect_timeout").hasValue()) { auto const connectTimeoutSecond = config_.get("connect_timeout"); settings.connectionTimeout = - std::chrono::milliseconds{connectTimeoutSecond * util::kMILLISECONDS_PER_SECOND}; + std::chrono::milliseconds{connectTimeoutSecond * util::kMillisecondsPerSecond}; } if (config_.getValueView("request_timeout").hasValue()) { auto const requestTimeoutSecond = config_.get("request_timeout"); settings.requestTimeout = - std::chrono::milliseconds{requestTimeoutSecond * util::kMILLISECONDS_PER_SECOND}; + std::chrono::milliseconds{requestTimeoutSecond * util::kMillisecondsPerSecond}; } settings.certificate = parseOptionalCertificate(); diff --git a/src/data/cassandra/impl/Batch.cpp b/src/data/cassandra/impl/Batch.cpp index aa52d5dad..e186aefb6 100644 --- a/src/data/cassandra/impl/Batch.cpp +++ b/src/data/cassandra/impl/Batch.cpp @@ -12,7 +12,7 @@ #include namespace { -constexpr auto kBATCH_DELETER = [](CassBatch* ptr) { cass_batch_free(ptr); }; +constexpr auto kBatchDeleter = [](CassBatch* ptr) { cass_batch_free(ptr); }; } // namespace namespace data::cassandra::impl { @@ -29,7 +29,7 @@ namespace data::cassandra::impl { * https://docs.datastax.com/en/developer/cpp-driver-dse/1.10/features/basics/batches/index.html */ Batch::Batch(std::vector const& statements) - : ManagedObject{cass_batch_new(CASS_BATCH_TYPE_UNLOGGED), kBATCH_DELETER} + : ManagedObject{cass_batch_new(CASS_BATCH_TYPE_UNLOGGED), kBatchDeleter} { cass_batch_set_is_idempotent(*this, cass_true); diff --git a/src/data/cassandra/impl/Cluster.cpp b/src/data/cassandra/impl/Cluster.cpp index c75c42d3a..904e9f4d0 100644 --- a/src/data/cassandra/impl/Cluster.cpp +++ b/src/data/cassandra/impl/Cluster.cpp @@ -14,13 +14,13 @@ namespace { -constexpr auto kCLUSTER_DELETER = [](CassCluster* ptr) { cass_cluster_free(ptr); }; +constexpr auto kClusterDeleter = [](CassCluster* ptr) { cass_cluster_free(ptr); }; }; // namespace namespace data::cassandra::impl { -Cluster::Cluster(Settings const& settings) : ManagedObject{cass_cluster_new(), kCLUSTER_DELETER} +Cluster::Cluster(Settings const& settings) : ManagedObject{cass_cluster_new(), kClusterDeleter} { using std::to_string; diff --git a/src/data/cassandra/impl/Cluster.hpp b/src/data/cassandra/impl/Cluster.hpp index 7d445d1d2..e0d015532 100644 --- a/src/data/cassandra/impl/Cluster.hpp +++ b/src/data/cassandra/impl/Cluster.hpp @@ -35,11 +35,11 @@ providerFromString(std::string const& provider) * @brief Bundles all cassandra settings in one place. */ struct Settings { - static constexpr std::size_t kDEFAULT_CONNECTION_TIMEOUT = 10000; - static constexpr uint32_t kDEFAULT_MAX_WRITE_REQUESTS_OUTSTANDING = 10'000; - static constexpr uint32_t kDEFAULT_MAX_READ_REQUESTS_OUTSTANDING = 100'000; - static constexpr std::size_t kDEFAULT_BATCH_SIZE = 20; - static constexpr Provider kDEFAULT_PROVIDER = Provider::Cassandra; + static constexpr std::size_t kDefaultConnectionTimeout = 10000; + static constexpr uint32_t kDefaultMaxWriteRequestsOutstanding = 10'000; + static constexpr uint32_t kDefaultMaxReadRequestsOutstanding = 100'000; + static constexpr std::size_t kDefaultBatchSize = 20; + static constexpr Provider kDefaultProvider = Provider::Cassandra; /** * @brief Represents the configuration of contact points for cassandra. @@ -61,7 +61,7 @@ struct Settings { /** @brief Connect timeout specified in milliseconds */ std::chrono::milliseconds connectionTimeout = - std::chrono::milliseconds{kDEFAULT_CONNECTION_TIMEOUT}; + std::chrono::milliseconds{kDefaultConnectionTimeout}; /** @brief Request timeout specified in milliseconds */ std::chrono::milliseconds requestTimeout = std::chrono::milliseconds{0}; // no timeout at all @@ -73,19 +73,19 @@ struct Settings { uint32_t threads = std::thread::hardware_concurrency(); /** @brief The maximum number of outstanding write requests at any given moment */ - uint32_t maxWriteRequestsOutstanding = kDEFAULT_MAX_WRITE_REQUESTS_OUTSTANDING; + uint32_t maxWriteRequestsOutstanding = kDefaultMaxWriteRequestsOutstanding; /** @brief The maximum number of outstanding read requests at any given moment */ - uint32_t maxReadRequestsOutstanding = kDEFAULT_MAX_READ_REQUESTS_OUTSTANDING; + uint32_t maxReadRequestsOutstanding = kDefaultMaxReadRequestsOutstanding; /** @brief The number of connection per host to always have active */ uint32_t coreConnectionsPerHost = 3u; /** @brief Size of batches when writing */ - std::size_t writeBatchSize = kDEFAULT_BATCH_SIZE; + std::size_t writeBatchSize = kDefaultBatchSize; /** @brief Provider to know if we are using scylladb or keyspace */ - Provider provider = kDEFAULT_PROVIDER; + Provider provider = kDefaultProvider; /** @brief Size of the IO queue */ std::optional queueSizeIO = diff --git a/src/data/cassandra/impl/Collection.hpp b/src/data/cassandra/impl/Collection.hpp index 8ee404dbb..20db6bcd7 100644 --- a/src/data/cassandra/impl/Collection.hpp +++ b/src/data/cassandra/impl/Collection.hpp @@ -14,7 +14,7 @@ namespace data::cassandra::impl { class Collection : public ManagedObject { - static constexpr auto kDELETER = [](CassCollection* ptr) { cass_collection_free(ptr); }; + static constexpr auto kDeleter = [](CassCollection* ptr) { cass_collection_free(ptr); }; static void throwErrorIfNeeded(CassError const rc, std::string_view const label) @@ -30,7 +30,7 @@ public: template explicit Collection(std::vector const& value) - : ManagedObject{cass_collection_new(CASS_COLLECTION_TYPE_LIST, value.size()), kDELETER} + : ManagedObject{cass_collection_new(CASS_COLLECTION_TYPE_LIST, value.size()), kDeleter} { bind(value); } diff --git a/src/data/cassandra/impl/Future.cpp b/src/data/cassandra/impl/Future.cpp index a86ef5645..813499efb 100644 --- a/src/data/cassandra/impl/Future.cpp +++ b/src/data/cassandra/impl/Future.cpp @@ -13,12 +13,12 @@ #include namespace { -constexpr auto kFUTURE_DELETER = [](CassFuture* ptr) { cass_future_free(ptr); }; +constexpr auto kFutureDeleter = [](CassFuture* ptr) { cass_future_free(ptr); }; } // namespace namespace data::cassandra::impl { -/* implicit */ Future::Future(CassFuture* ptr) : ManagedObject{ptr, kFUTURE_DELETER} +/* implicit */ Future::Future(CassFuture* ptr) : ManagedObject{ptr, kFutureDeleter} { } diff --git a/src/data/cassandra/impl/Result.cpp b/src/data/cassandra/impl/Result.cpp index dcfeaf3d2..e5ffb6619 100644 --- a/src/data/cassandra/impl/Result.cpp +++ b/src/data/cassandra/impl/Result.cpp @@ -7,13 +7,13 @@ #include namespace { -constexpr auto kRESULT_DELETER = [](CassResult const* ptr) { cass_result_free(ptr); }; -constexpr auto kRESULT_ITERATOR_DELETER = [](CassIterator* ptr) { cass_iterator_free(ptr); }; +constexpr auto kResultDeleter = [](CassResult const* ptr) { cass_result_free(ptr); }; +constexpr auto kResultIteratorDeleter = [](CassIterator* ptr) { cass_iterator_free(ptr); }; } // namespace namespace data::cassandra::impl { -/* implicit */ Result::Result(CassResult const* ptr) : ManagedObject{ptr, kRESULT_DELETER} +/* implicit */ Result::Result(CassResult const* ptr) : ManagedObject{ptr, kResultDeleter} { } @@ -30,7 +30,7 @@ Result::hasRows() const } /* implicit */ ResultIterator::ResultIterator(CassIterator* ptr) - : ManagedObject{ptr, kRESULT_ITERATOR_DELETER}, hasMore_{cass_iterator_next(ptr) != 0u} + : ManagedObject{ptr, kResultIteratorDeleter}, hasMore_{cass_iterator_next(ptr) != 0u} { } diff --git a/src/data/cassandra/impl/Session.hpp b/src/data/cassandra/impl/Session.hpp index 013667020..313500403 100644 --- a/src/data/cassandra/impl/Session.hpp +++ b/src/data/cassandra/impl/Session.hpp @@ -7,10 +7,10 @@ namespace data::cassandra::impl { class Session : public ManagedObject { - static constexpr auto kDELETER = [](CassSession* ptr) { cass_session_free(ptr); }; + static constexpr auto kDeleter = [](CassSession* ptr) { cass_session_free(ptr); }; public: - Session() : ManagedObject{cass_session_new(), kDELETER} + Session() : ManagedObject{cass_session_new(), kDeleter} { } }; diff --git a/src/data/cassandra/impl/SslContext.cpp b/src/data/cassandra/impl/SslContext.cpp index 92232bf21..5e6addafe 100644 --- a/src/data/cassandra/impl/SslContext.cpp +++ b/src/data/cassandra/impl/SslContext.cpp @@ -8,13 +8,13 @@ #include namespace { -constexpr auto kCONTEXT_DELETER = [](CassSsl* ptr) { cass_ssl_free(ptr); }; +constexpr auto kContextDeleter = [](CassSsl* ptr) { cass_ssl_free(ptr); }; } // namespace namespace data::cassandra::impl { SslContext::SslContext(std::string const& certificate) - : ManagedObject{cass_ssl_new(), kCONTEXT_DELETER} + : ManagedObject{cass_ssl_new(), kContextDeleter} { cass_ssl_set_verify_flags(*this, CASS_SSL_VERIFY_NONE); if (auto const rc = cass_ssl_add_trusted_cert(*this, certificate.c_str()); rc != CASS_OK) { diff --git a/src/data/cassandra/impl/Statement.hpp b/src/data/cassandra/impl/Statement.hpp index d70aeb65c..271d82d04 100644 --- a/src/data/cassandra/impl/Statement.hpp +++ b/src/data/cassandra/impl/Statement.hpp @@ -26,7 +26,7 @@ namespace data::cassandra::impl { class Statement : public ManagedObject { - static constexpr auto kDELETER = [](CassStatement* ptr) { cass_statement_free(ptr); }; + static constexpr auto kDeleter = [](CassStatement* ptr) { cass_statement_free(ptr); }; public: /** @@ -37,7 +37,7 @@ public: */ template explicit Statement(std::string_view query, Args&&... args) - : ManagedObject{cass_statement_new_n(query.data(), query.size(), sizeof...(args)), kDELETER} + : ManagedObject{cass_statement_new_n(query.data(), query.size(), sizeof...(args)), kDeleter} { // TODO: figure out how to set consistency level in config // NOTE: Keyspace doesn't support QUORUM at write level @@ -46,7 +46,7 @@ public: bind(std::forward(args)...); } - /* implicit */ Statement(CassStatement* ptr) : ManagedObject{ptr, kDELETER} + /* implicit */ Statement(CassStatement* ptr) : ManagedObject{ptr, kDeleter} { // cass_statement_set_consistency(*this, CASS_CONSISTENCY_LOCAL_QUORUM); cass_statement_set_is_idempotent(*this, cass_true); @@ -157,10 +157,10 @@ public: * This is used to produce Statement objects that can be executed. */ class PreparedStatement : public ManagedObject { - static constexpr auto kDELETER = [](CassPrepared const* ptr) { cass_prepared_free(ptr); }; + static constexpr auto kDeleter = [](CassPrepared const* ptr) { cass_prepared_free(ptr); }; public: - /* implicit */ PreparedStatement(CassPrepared const* ptr) : ManagedObject{ptr, kDELETER} + /* implicit */ PreparedStatement(CassPrepared const* ptr) : ManagedObject{ptr, kDeleter} { } diff --git a/src/data/cassandra/impl/Tuple.cpp b/src/data/cassandra/impl/Tuple.cpp index b4caa94a0..12cea9ae2 100644 --- a/src/data/cassandra/impl/Tuple.cpp +++ b/src/data/cassandra/impl/Tuple.cpp @@ -5,18 +5,18 @@ #include namespace { -constexpr auto kTUPLE_DELETER = [](CassTuple* ptr) { cass_tuple_free(ptr); }; -constexpr auto kTUPLE_ITERATOR_DELETER = [](CassIterator* ptr) { cass_iterator_free(ptr); }; +constexpr auto kTupleDeleter = [](CassTuple* ptr) { cass_tuple_free(ptr); }; +constexpr auto kTupleIteratorDeleter = [](CassIterator* ptr) { cass_iterator_free(ptr); }; } // namespace namespace data::cassandra::impl { -/* implicit */ Tuple::Tuple(CassTuple* ptr) : ManagedObject{ptr, kTUPLE_DELETER} +/* implicit */ Tuple::Tuple(CassTuple* ptr) : ManagedObject{ptr, kTupleDeleter} { } /* implicit */ TupleIterator::TupleIterator(CassIterator* ptr) - : ManagedObject{ptr, kTUPLE_ITERATOR_DELETER} + : ManagedObject{ptr, kTupleIteratorDeleter} { } diff --git a/src/data/cassandra/impl/Tuple.hpp b/src/data/cassandra/impl/Tuple.hpp index 8f04ababa..5c8f48c5f 100644 --- a/src/data/cassandra/impl/Tuple.hpp +++ b/src/data/cassandra/impl/Tuple.hpp @@ -18,14 +18,14 @@ namespace data::cassandra::impl { class Tuple : public ManagedObject { - static constexpr auto kDELETER = [](CassTuple* ptr) { cass_tuple_free(ptr); }; + static constexpr auto kDeleter = [](CassTuple* ptr) { cass_tuple_free(ptr); }; public: /* implicit */ Tuple(CassTuple* ptr); template explicit Tuple(std::tuple&& value) - : ManagedObject{cass_tuple_new(std::tuple_size>{}), kDELETER} + : ManagedObject{cass_tuple_new(std::tuple_size>{}), kDeleter} { std::apply(std::bind_front(&Tuple::bind, this), std::move(value)); } diff --git a/src/data/impl/LedgerCacheFile.cpp b/src/data/impl/LedgerCacheFile.cpp index 3abfe045a..52bc370bd 100644 --- a/src/data/impl/LedgerCacheFile.cpp +++ b/src/data/impl/LedgerCacheFile.cpp @@ -19,7 +19,7 @@ namespace data::impl { using Hash = ripple::uint256; using Separator = std::array; -static constexpr Separator kSEPARATOR = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +static constexpr Separator kSeparator = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; namespace { @@ -78,7 +78,7 @@ LedgerCacheFile::write(DataView dataView) .deletedSize = dataView.deleted.size() }; file.write(header); - file.write(kSEPARATOR); + file.write(kSeparator); for (auto const& [k, v] : dataView.map) { file.write(k.data(), decltype(k)::bytes); @@ -86,7 +86,7 @@ LedgerCacheFile::write(DataView dataView) file.write(v.blob.size()); file.writeRaw(reinterpret_cast(v.blob.data()), v.blob.size()); } - file.write(kSEPARATOR); + file.write(kSeparator); for (auto const& [k, v] : dataView.deleted) { file.write(k.data(), decltype(k)::bytes); @@ -94,7 +94,7 @@ LedgerCacheFile::write(DataView dataView) file.write(v.blob.size()); file.writeRaw(reinterpret_cast(v.blob.data()), v.blob.size()); } - file.write(kSEPARATOR); + file.write(kSeparator); auto const hash = file.hash(); file.write(hash.data(), decltype(hash)::bytes); @@ -129,9 +129,9 @@ LedgerCacheFile::read(uint32_t minLatestSequence) if (not file.read(header)) { return std::unexpected{"Error reading cache header"}; } - if (header.version != kVERSION) { + if (header.version != kVersion) { return std::unexpected{fmt::format( - "Cache has wrong version: expected {} found {}", kVERSION, header.version + "Cache has wrong version: expected {} found {}", kVersion, header.version )}; } if (header.latestSeq < minLatestSequence) { diff --git a/src/data/impl/LedgerCacheFile.hpp b/src/data/impl/LedgerCacheFile.hpp index 2b1652aee..45b0ae669 100644 --- a/src/data/impl/LedgerCacheFile.hpp +++ b/src/data/impl/LedgerCacheFile.hpp @@ -17,14 +17,14 @@ namespace data::impl { class LedgerCacheFile { public: struct Header { - uint32_t version = kVERSION; + uint32_t version = kVersion; uint32_t latestSeq{}; uint64_t mapSize{}; uint64_t deletedSize{}; }; private: - static constexpr uint32_t kVERSION = 1; + static constexpr uint32_t kVersion = 1; std::string path_; diff --git a/src/etl/LoadBalancer.cpp b/src/etl/LoadBalancer.cpp index 50f8fb14e..3f9c784e9 100644 --- a/src/etl/LoadBalancer.cpp +++ b/src/etl/LoadBalancer.cpp @@ -289,7 +289,7 @@ LoadBalancer::forwardToRippled( auto numAttempts = 0u; - auto xUserValue = isAdmin ? kADMIN_FORWARDING_X_USER_VALUE : kUSER_FORWARDING_X_USER_VALUE; + auto xUserValue = isAdmin ? kAdminForwardingXUserValue : kUserForwardingXUserValue; std::optional response; rpc::ClioError error = rpc::ClioError::EtlConnectionError; diff --git a/src/etl/LoadBalancer.hpp b/src/etl/LoadBalancer.hpp index 30896f68e..8fb9a3681 100644 --- a/src/etl/LoadBalancer.hpp +++ b/src/etl/LoadBalancer.hpp @@ -63,7 +63,7 @@ public: using OptionalGetLedgerResponseType = std::optional; private: - static constexpr std::uint32_t kDEFAULT_DOWNLOAD_RANGES = 16; + static constexpr std::uint32_t kDefaultDownloadRanges = 16; util::Logger log_{"ETL"}; // Forwarding cache must be destroyed after sources because sources have a callback to @@ -75,7 +75,7 @@ private: std::vector sources_; std::optional etlState_; - std::uint32_t downloadRanges_ = kDEFAULT_DOWNLOAD_RANGES; /*< The number of markers to use when + std::uint32_t downloadRanges_ = kDefaultDownloadRanges; /*< The number of markers to use when downloading initial ledger */ struct ForwardingCounters { @@ -95,12 +95,12 @@ public: /** * @brief Value for the X-User header when forwarding admin requests */ - static constexpr std::string_view kADMIN_FORWARDING_X_USER_VALUE = "clio_admin"; + static constexpr std::string_view kAdminForwardingXUserValue = "clio_admin"; /** * @brief Value for the X-User header when forwarding user requests */ - static constexpr std::string_view kUSER_FORWARDING_X_USER_VALUE = "clio_user"; + static constexpr std::string_view kUserForwardingXUserValue = "clio_user"; /** * @brief Create an instance of the load balancer. diff --git a/src/etl/Models.hpp b/src/etl/Models.hpp index 401181ecf..9d07d4275 100644 --- a/src/etl/Models.hpp +++ b/src/etl/Models.hpp @@ -31,7 +31,7 @@ namespace etl::model { template requires(util::hasNoDuplicates(Types...)) struct Spec { - static constexpr bool kSPEC_TAG = true; + static constexpr bool kSpecTag = true; /** * @brief Checks if the transaction type was requested. diff --git a/src/etl/MonitorInterface.hpp b/src/etl/MonitorInterface.hpp index 953dfa8c0..c095abecb 100644 --- a/src/etl/MonitorInterface.hpp +++ b/src/etl/MonitorInterface.hpp @@ -16,7 +16,7 @@ namespace etl { */ class MonitorInterface { public: - static constexpr auto kDEFAULT_REPEAT_INTERVAL = std::chrono::seconds{1}; + static constexpr auto kDefaultRepeatInterval = std::chrono::seconds{1}; using NewSequenceSignalType = boost::signals2::signal; using DbStalledSignalType = boost::signals2::signal; @@ -61,7 +61,7 @@ public: * @param repeatInterval The interval between attempts to check the database for new ledgers */ virtual void - run(std::chrono::steady_clock::duration repeatInterval = kDEFAULT_REPEAT_INTERVAL) = 0; + run(std::chrono::steady_clock::duration repeatInterval = kDefaultRepeatInterval) = 0; /** * @brief Stops the monitor service diff --git a/src/etl/MonitorProviderInterface.hpp b/src/etl/MonitorProviderInterface.hpp index 3f6c029c8..7a5050db0 100644 --- a/src/etl/MonitorProviderInterface.hpp +++ b/src/etl/MonitorProviderInterface.hpp @@ -18,7 +18,7 @@ struct MonitorProviderInterface { /** * @brief The time Monitor should wait before reporting absence of updates to the database */ - static constexpr auto kDEFAULT_DB_STALLED_REPORT_DELAY = std::chrono::seconds{10}; + static constexpr auto kDefaultDbStalledReportDelay = std::chrono::seconds{10}; virtual ~MonitorProviderInterface() = default; @@ -38,7 +38,7 @@ struct MonitorProviderInterface { std::shared_ptr backend, std::shared_ptr validatedLedgers, uint32_t startSequence, - std::chrono::steady_clock::duration dbStalledReportDelay = kDEFAULT_DB_STALLED_REPORT_DELAY + std::chrono::steady_clock::duration dbStalledReportDelay = kDefaultDbStalledReportDelay ) = 0; }; diff --git a/src/etl/impl/AmendmentBlockHandler.cpp b/src/etl/impl/AmendmentBlockHandler.cpp index b200b2f33..2d3f4407d 100644 --- a/src/etl/impl/AmendmentBlockHandler.cpp +++ b/src/etl/impl/AmendmentBlockHandler.cpp @@ -11,15 +11,14 @@ namespace etl::impl { -AmendmentBlockHandler::ActionType const AmendmentBlockHandler::kDEFAULT_AMENDMENT_BLOCK_ACTION = - []() { - static util::Logger const log{"ETL"}; // NOLINT(readability-identifier-naming) - LOG( - log.fatal() - ) << "Can't process new ledgers: The current ETL source is not compatible with the version " - "of " - << "the libxrpl Clio is currently using. Please upgrade Clio to a newer version."; - }; +AmendmentBlockHandler::ActionType const AmendmentBlockHandler::kDefaultAmendmentBlockAction = []() { + static util::Logger const log{"ETL"}; // NOLINT(readability-identifier-naming) + LOG( + log.fatal() + ) << "Can't process new ledgers: The current ETL source is not compatible with the version " + "of " + << "the libxrpl Clio is currently using. Please upgrade Clio to a newer version."; +}; AmendmentBlockHandler::AmendmentBlockHandler( util::async::AnyExecutionContext ctx, diff --git a/src/etl/impl/AmendmentBlockHandler.hpp b/src/etl/impl/AmendmentBlockHandler.hpp index cedc78f98..1307ada68 100644 --- a/src/etl/impl/AmendmentBlockHandler.hpp +++ b/src/etl/impl/AmendmentBlockHandler.hpp @@ -28,13 +28,13 @@ private: ActionType action_; public: - static ActionType const kDEFAULT_AMENDMENT_BLOCK_ACTION; + static ActionType const kDefaultAmendmentBlockAction; AmendmentBlockHandler( util::async::AnyExecutionContext ctx, SystemState& state, std::chrono::steady_clock::duration interval = std::chrono::seconds{1}, - ActionType action = kDEFAULT_AMENDMENT_BLOCK_ACTION + ActionType action = kDefaultAmendmentBlockAction ); ~AmendmentBlockHandler() override; diff --git a/src/etl/impl/CursorFromAccountProvider.hpp b/src/etl/impl/CursorFromAccountProvider.hpp index 19eed1475..303d1a975 100644 --- a/src/etl/impl/CursorFromAccountProvider.hpp +++ b/src/etl/impl/CursorFromAccountProvider.hpp @@ -43,10 +43,10 @@ public: }(); rg::sort(accountRoots); - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFirstKey}; rg::copy(accountRoots.begin(), accountRoots.end(), std::back_inserter(cursors)); rg::sort(cursors); - cursors.push_back(data::kLAST_KEY); + cursors.push_back(data::kLastKey); std::vector pairs; pairs.reserve(cursors.size()); diff --git a/src/etl/impl/CursorFromDiffProvider.hpp b/src/etl/impl/CursorFromDiffProvider.hpp index 538809a09..c1b6ef766 100644 --- a/src/etl/impl/CursorFromDiffProvider.hpp +++ b/src/etl/impl/CursorFromDiffProvider.hpp @@ -67,13 +67,13 @@ public: ); } - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFirstKey}; rg::copy( liveCursors | vs::take(std::min(liveCursors.size(), numCursors_)), std::back_inserter(cursors) ); rg::sort(cursors); - cursors.push_back(data::kLAST_KEY); + cursors.push_back(data::kLastKey); std::vector pairs; pairs.reserve(cursors.size()); diff --git a/src/etl/impl/CursorFromFixDiffNumProvider.hpp b/src/etl/impl/CursorFromFixDiffNumProvider.hpp index f3cdcac1c..b74ea7502 100644 --- a/src/etl/impl/CursorFromFixDiffNumProvider.hpp +++ b/src/etl/impl/CursorFromFixDiffNumProvider.hpp @@ -57,14 +57,14 @@ public: rg::unique(diffs, [](auto const& a, auto const& b) { return a.key == b.key; }); diffs.erase(removalCursor, last); - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFirstKey}; rg::copy( diffs // | vs::filter([](auto const& obj) { return not obj.blob.empty(); }) // | vs::transform([](auto const& obj) { return obj.key; }), std::back_inserter(cursors) ); - cursors.push_back(data::kLAST_KEY); // last pair should cover the remaining range + cursors.push_back(data::kLastKey); // last pair should cover the remaining range std::vector pairs; pairs.reserve(cursors.size()); diff --git a/src/etl/impl/Extraction.cpp b/src/etl/impl/Extraction.cpp index 93256a22a..cf29a3559 100644 --- a/src/etl/impl/Extraction.cpp +++ b/src/etl/impl/Extraction.cpp @@ -108,8 +108,8 @@ extractObj(PBObjType obj) .keyRaw = std::move(*obj.mutable_key()), .data = {obj.mutable_data()->begin(), obj.mutable_data()->end()}, .dataRaw = std::move(*obj.mutable_data()), - .successor = valueOr(obj.successor(), uint256ToString(data::kFIRST_KEY)), - .predecessor = valueOr(obj.predecessor(), uint256ToString(data::kLAST_KEY)), + .successor = valueOr(obj.successor(), uint256ToString(data::kFirstKey)), + .predecessor = valueOr(obj.predecessor(), uint256ToString(data::kLastKey)), .type = extractModType(obj.mod_type()), }; } diff --git a/src/etl/impl/ForwardingSource.hpp b/src/etl/impl/ForwardingSource.hpp index 05d2dee80..3806b9b71 100644 --- a/src/etl/impl/ForwardingSource.hpp +++ b/src/etl/impl/ForwardingSource.hpp @@ -20,14 +20,14 @@ class ForwardingSource { util::requests::WsConnectionBuilder connectionBuilder_; std::chrono::steady_clock::duration forwardingTimeout_; - static constexpr std::chrono::seconds kCONNECTION_TIMEOUT{3}; + static constexpr std::chrono::seconds kConnectionTimeout{3}; public: ForwardingSource( std::string ip, std::string wsPort, std::chrono::steady_clock::duration forwardingTimeout, - std::chrono::steady_clock::duration connTimeout = ForwardingSource::kCONNECTION_TIMEOUT + std::chrono::steady_clock::duration connTimeout = ForwardingSource::kConnectionTimeout ); /** diff --git a/src/etl/impl/GrpcSource.cpp b/src/etl/impl/GrpcSource.cpp index 849eb517c..fc2bb8e3b 100644 --- a/src/etl/impl/GrpcSource.cpp +++ b/src/etl/impl/GrpcSource.cpp @@ -58,13 +58,12 @@ GrpcSource::GrpcSource( try { grpc::ChannelArguments chArgs; chArgs.SetMaxReceiveMessageSize(-1); - chArgs.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, kKEEPALIVE_PING_INTERVAL_MS); - chArgs.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, kKEEPALIVE_TIMEOUT_MS); + chArgs.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, kKeepalivePingIntervalMs); + chArgs.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, kKeepaliveTimeoutMs); chArgs.SetInt( - GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, - static_cast(kKEEPALIVE_PERMIT_WITHOUT_CALLS) + GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, static_cast(kKeepalivePermitWithoutCalls) ); - chArgs.SetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, kMAX_PINGS_WITHOUT_DATA); + chArgs.SetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, kMaxPingsWithoutData); stub_ = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateCustomChannel( diff --git a/src/etl/impl/GrpcSource.hpp b/src/etl/impl/GrpcSource.hpp index d3065ed6d..65ae90282 100644 --- a/src/etl/impl/GrpcSource.hpp +++ b/src/etl/impl/GrpcSource.hpp @@ -24,18 +24,18 @@ class GrpcSource { std::unique_ptr initialLoadShouldStop_; std::chrono::system_clock::duration deadline_; - static constexpr auto kKEEPALIVE_PING_INTERVAL_MS = 10000; - static constexpr auto kKEEPALIVE_TIMEOUT_MS = 5000; - static constexpr auto kKEEPALIVE_PERMIT_WITHOUT_CALLS = - true; // Allow keepalive pings when no calls - static constexpr auto kMAX_PINGS_WITHOUT_DATA = 0; // No limit - static constexpr auto kDEADLINE = std::chrono::seconds(30); + static constexpr auto kKeepalivePingIntervalMs = 10000; + static constexpr auto kKeepaliveTimeoutMs = 5000; + static constexpr auto kKeepalivePermitWithoutCalls = + true; // Allow keepalive pings when no calls + static constexpr auto kMaxPingsWithoutData = 0; // No limit + static constexpr auto kDeadline = std::chrono::seconds(30); public: GrpcSource( std::string const& ip, std::string const& grpcPort, - std::chrono::system_clock::duration deadline = kDEADLINE + std::chrono::system_clock::duration deadline = kDeadline ); /** diff --git a/src/etl/impl/LedgerPublisher.hpp b/src/etl/impl/LedgerPublisher.hpp index 1fac36f4d..a75c6ae11 100644 --- a/src/etl/impl/LedgerPublisher.hpp +++ b/src/etl/impl/LedgerPublisher.hpp @@ -167,8 +167,8 @@ public: // if the ledger closed over MAX_LEDGER_AGE_SECONDS ago, assume we are still catching up // and don't publish - static constexpr std::uint32_t kMAX_LEDGER_AGE_SECONDS = 600; - if (age < kMAX_LEDGER_AGE_SECONDS) { + static constexpr std::uint32_t kMaxLedgerAgeSeconds = 600; + if (age < kMaxLedgerAgeSeconds) { std::optional fees = data::synchronousAndRetryOnTimeout([&](auto yield) { return backend_->fetchFees(lgrInfo.seq, yield); @@ -246,9 +246,9 @@ public: std::chrono::system_clock::now().time_since_epoch() ) .count(); - if (now < (kRIPPLE_EPOCH_START + closeTime)) + if (now < (kRippleEpochStart + closeTime)) return 0; - return now - (kRIPPLE_EPOCH_START + closeTime); + return now - (kRippleEpochStart + closeTime); } /** diff --git a/src/etl/impl/Loading.cpp b/src/etl/impl/Loading.cpp index 74738b127..4daef36b7 100644 --- a/src/etl/impl/Loading.cpp +++ b/src/etl/impl/Loading.cpp @@ -83,8 +83,8 @@ Loader::onInitialLoadGotMoreObjects( std::optional lastKey ) { - static constexpr std::size_t kLOG_STRIDE = 1000u; - static auto kINITIAL_LOAD_START_TIME = std::chrono::steady_clock::now(); + static constexpr std::size_t kLogStride = 1000u; + static auto kInitialLoadStartTime = std::chrono::steady_clock::now(); try { LOG(log_.trace()) << "On initial load: got more objects for seq " << seq @@ -99,12 +99,12 @@ Loader::onInitialLoadGotMoreObjects( initialLoadWrittenObjects_ += data.size(); ++initialLoadWrites_; - if (initialLoadWrites_ % kLOG_STRIDE == 0u && initialLoadWrites_ != 0u) { + if (initialLoadWrites_ % kLogStride == 0u && initialLoadWrites_ != 0u) { auto elapsedSinceStart = std::chrono::duration_cast( - std::chrono::steady_clock::now() - kINITIAL_LOAD_START_TIME + std::chrono::steady_clock::now() - kInitialLoadStartTime ); auto elapsedSeconds = - elapsedSinceStart.count() / static_cast(util::kMILLISECONDS_PER_SECOND); + elapsedSinceStart.count() / static_cast(util::kMillisecondsPerSecond); auto objectsPerSecond = elapsedSeconds > 0.0 ? static_cast(initialLoadWrittenObjects_) / elapsedSeconds : 0.0; diff --git a/src/etl/impl/Registry.hpp b/src/etl/impl/Registry.hpp index cdad01dce..26d46e07b 100644 --- a/src/etl/impl/Registry.hpp +++ b/src/etl/impl/Registry.hpp @@ -57,7 +57,7 @@ concept HasInitialObjectHook = requires(T p) { }; template -concept ContainsSpec = std::decay_t::spec::kSPEC_TAG; +concept ContainsSpec = std::decay_t::spec::kSpecTag; template concept ContainsValidHook = diff --git a/src/etl/impl/Scheduling.hpp b/src/etl/impl/Scheduling.hpp index 22a3157c2..87aeb757a 100644 --- a/src/etl/impl/Scheduling.hpp +++ b/src/etl/impl/Scheduling.hpp @@ -49,11 +49,11 @@ public: [[nodiscard]] std::optional next() override { - static constexpr auto kMAX = std::numeric_limits::max(); + static constexpr auto kMax = std::numeric_limits::max(); uint32_t currentSeq = seq_; if (ledgers_.get().getMostRecent() >= currentSeq) { - while (currentSeq < maxSeq_.value_or(kMAX)) { + while (currentSeq < maxSeq_.value_or(kMax)) { if (seq_.compare_exchange_weak( currentSeq, currentSeq + 1u, std::memory_order_acq_rel )) { diff --git a/src/etl/impl/SubscriptionSource.cpp b/src/etl/impl/SubscriptionSource.cpp index d8618df9c..833d3ac04 100644 --- a/src/etl/impl/SubscriptionSource.cpp +++ b/src/etl/impl/SubscriptionSource.cpp @@ -58,7 +58,7 @@ SubscriptionSource::SubscriptionSource( , subscriptions_(std::move(subscriptions)) , strand_(boost::asio::make_strand(ioContext)) , wsTimeout_(wsTimeout) - , retry_(util::makeRetryExponentialBackoff(retryDelay, kRETRY_MAX_DELAY, strand_)) + , retry_(util::makeRetryExponentialBackoff(retryDelay, kRetryMaxDelay, strand_)) , onConnect_(std::move(onConnect)) , onDisconnect_(std::move(onDisconnect)) , onLedgerClosed_(std::move(onLedgerClosed)) @@ -198,9 +198,9 @@ SubscriptionSource::handleMessage(std::string const& message) auto const object = raw.as_object(); uint32_t ledgerIndex = 0; - static constexpr auto kJS_LEDGER_CLOSED = "ledgerClosed"; - static constexpr auto kJS_VALIDATION_RECEIVED = "validationReceived"; - static constexpr auto kJS_MANIFEST_RECEIVED = "manifestReceived"; + static constexpr auto kJsLedgerClosed = "ledgerClosed"; + static constexpr auto kJsValidationReceived = "validationReceived"; + static constexpr auto kJsManifestReceived = "manifestReceived"; if (object.contains(JS(result))) { auto const& result = object.at(JS(result)).as_object(); @@ -215,7 +215,7 @@ SubscriptionSource::handleMessage(std::string const& message) LOG(log_.debug()) << "Received a message on ledger subscription stream. Message: " << object; - } else if (object.contains(JS(type)) && object.at(JS(type)) == kJS_LEDGER_CLOSED) { + } else if (object.contains(JS(type)) && object.at(JS(type)) == kJsLedgerClosed) { LOG(log_.debug()) << "Received a message of type 'ledgerClosed' on ledger subscription " "stream. Message: " << object; @@ -239,12 +239,12 @@ SubscriptionSource::handleMessage(std::string const& message) LOG(log_.debug()) << "Forwarding proposed transaction: " << object; subscriptions_->forwardProposedTransaction(object); } else if ( - object.contains(JS(type)) && object.at(JS(type)) == kJS_VALIDATION_RECEIVED + object.contains(JS(type)) && object.at(JS(type)) == kJsValidationReceived ) { LOG(log_.debug()) << "Forwarding validation: " << object; subscriptions_->forwardValidation(object); } else if ( - object.contains(JS(type)) && object.at(JS(type)) == kJS_MANIFEST_RECEIVED + object.contains(JS(type)) && object.at(JS(type)) == kJsManifestReceived ) { LOG(log_.debug()) << "Forwarding manifest: " << object; subscriptions_->forwardManifest(object); @@ -358,12 +358,12 @@ SubscriptionSource::setValidatedRange(std::string range) std::string const& SubscriptionSource::getSubscribeCommandJson() { - static boost::json::object const kJSON_VALUE{ + static boost::json::object const kJsonValue{ {"command", "subscribe"}, {"streams", {"ledger", "manifests", "validations", "transactions_proposed"}}, }; - static std::string const kJSON_STRING = boost::json::serialize(kJSON_VALUE); - return kJSON_STRING; + static std::string const kJsonString = boost::json::serialize(kJsonValue); + return kJsonString; } } // namespace etl::impl diff --git a/src/etl/impl/SubscriptionSource.hpp b/src/etl/impl/SubscriptionSource.hpp index 021ce3d72..1e35181fe 100644 --- a/src/etl/impl/SubscriptionSource.hpp +++ b/src/etl/impl/SubscriptionSource.hpp @@ -74,9 +74,9 @@ private: util::StopHelper stopHelper_; - static constexpr std::chrono::seconds kWS_TIMEOUT{30}; - static constexpr std::chrono::seconds kRETRY_MAX_DELAY{30}; - static constexpr std::chrono::seconds kRETRY_DELAY{1}; + static constexpr std::chrono::seconds kWsTimeout{30}; + static constexpr std::chrono::seconds kRetryMaxDelay{30}; + static constexpr std::chrono::seconds kRetryDelay{1}; public: /** @@ -104,8 +104,8 @@ public: OnConnectHook onConnect, OnDisconnectHook onDisconnect, OnLedgerClosedHook onLedgerClosed, - std::chrono::steady_clock::duration const wsTimeout = SubscriptionSource::kWS_TIMEOUT, - std::chrono::steady_clock::duration const retryDelay = SubscriptionSource::kRETRY_DELAY + std::chrono::steady_clock::duration const wsTimeout = SubscriptionSource::kWsTimeout, + std::chrono::steady_clock::duration const retryDelay = SubscriptionSource::kRetryDelay ); /** diff --git a/src/etl/impl/TaskManager.cpp b/src/etl/impl/TaskManager.cpp index 2bbc4d80e..bde4bd51a 100644 --- a/src/etl/impl/TaskManager.cpp +++ b/src/etl/impl/TaskManager.cpp @@ -40,7 +40,7 @@ TaskManager::TaskManager( , extractor_(extractor) , loader_(loader) , monitor_(monitor) - , queue_({.startSeq = startSeq, .increment = 1u, .limit = kQUEUE_SIZE_LIMIT}) + , queue_({.startSeq = startSeq, .increment = 1u, .limit = kQueueSizeLimit}) { } @@ -70,8 +70,8 @@ TaskManager::spawnExtractor(TaskQueue& queue) { // TODO https://github.com/XRPLF/clio/issues/2838: the approach should be changed to a reactive // one instead - static constexpr auto kDELAY_BETWEEN_ATTEMPTS = std::chrono::milliseconds{10u}; - static constexpr auto kDELAY_BETWEEN_ENQUEUE_ATTEMPTS = std::chrono::milliseconds{1u}; + static constexpr auto kDelayBetweenAttempts = std::chrono::milliseconds{10u}; + static constexpr auto kDelayBetweenEnqueueAttempts = std::chrono::milliseconds{1u}; return ctx_.execute([this, &queue](auto stopRequested) { while (not stopRequested) { @@ -81,7 +81,7 @@ TaskManager::spawnExtractor(TaskQueue& queue) LOG(log_.debug()) << "Adding data after extracting diff"; while (not queue.enqueue(*maybeBatch)) { // TODO (https://github.com/XRPLF/clio/issues/1852) - std::this_thread::sleep_for(kDELAY_BETWEEN_ENQUEUE_ATTEMPTS); + std::this_thread::sleep_for(kDelayBetweenEnqueueAttempts); if (stopRequested) break; @@ -89,7 +89,7 @@ TaskManager::spawnExtractor(TaskQueue& queue) } } else { // TODO (https://github.com/XRPLF/clio/issues/1852) - std::this_thread::sleep_for(kDELAY_BETWEEN_ATTEMPTS); + std::this_thread::sleep_for(kDelayBetweenAttempts); } } @@ -130,7 +130,7 @@ TaskManager::spawnLoader(TaskQueue& queue) if (shouldExitOnError) break; - auto const seconds = nanos / util::kNANO_PER_SECOND; + auto const seconds = nanos / util::kNanoPerSecond; auto const txnCount = data->transactions.size(); auto const objCount = data->objects.size(); diff --git a/src/etl/impl/TaskManager.hpp b/src/etl/impl/TaskManager.hpp index da8f2aaba..0ff85885d 100644 --- a/src/etl/impl/TaskManager.hpp +++ b/src/etl/impl/TaskManager.hpp @@ -23,7 +23,7 @@ namespace etl::impl { class TaskManager : public TaskManagerInterface { - static constexpr auto kQUEUE_SIZE_LIMIT = 2048uz; + static constexpr auto kQueueSizeLimit = 2048uz; util::async::AnyExecutionContext ctx_; std::shared_ptr schedulers_; diff --git a/src/etl/impl/ext/Successor.cpp b/src/etl/impl/ext/Successor.cpp index 5bb012141..f084b85be 100644 --- a/src/etl/impl/ext/Successor.cpp +++ b/src/etl/impl/ext/Successor.cpp @@ -86,7 +86,7 @@ SuccessorExt::writeIncludedSuccessor(uint32_t seq, model::BookSuccessor const& s { auto firstBook = succ.firstBook; if (firstBook.empty()) - firstBook = uint256ToString(data::kLAST_KEY); + firstBook = uint256ToString(data::kLastKey); backend_->writeSuccessor(auto{succ.bookBase}, seq, std::move(firstBook)); } @@ -116,10 +116,10 @@ SuccessorExt::updateSuccessorFromCache(uint32_t seq, model::Object const& obj) c { auto const lb = cache_.get() .getPredecessor(obj.key, seq) - .value_or(data::LedgerObject{.key = data::kFIRST_KEY, .blob = {}}); + .value_or(data::LedgerObject{.key = data::kFirstKey, .blob = {}}); auto const ub = cache_.get() .getSuccessor(obj.key, seq) - .value_or(data::LedgerObject{.key = data::kLAST_KEY, .blob = {}}); + .value_or(data::LedgerObject{.key = data::kLastKey, .blob = {}}); auto checkBookBase = false; auto const isDeleted = obj.data.empty(); @@ -169,16 +169,16 @@ SuccessorExt::updateBookSuccessor( uint256ToString(bookBase), seq, uint256ToString(maybeSuccessor->key) ); } else { - backend_->writeSuccessor(uint256ToString(bookBase), seq, uint256ToString(data::kLAST_KEY)); + backend_->writeSuccessor(uint256ToString(bookBase), seq, uint256ToString(data::kLastKey)); } } void SuccessorExt::writeSuccessors(uint32_t seq) const { - ripple::uint256 prev = data::kFIRST_KEY; + ripple::uint256 prev = data::kFirstKey; while (auto cur = cache_.get().getSuccessor(prev, seq)) { - if (prev == data::kFIRST_KEY) + if (prev == data::kFirstKey) backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(cur->key)); if (isBookDir(cur->key, cur->blob)) { @@ -199,7 +199,7 @@ SuccessorExt::writeSuccessors(uint32_t seq) const prev = cur->key; } - backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(data::kLAST_KEY)); + backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(data::kLastKey)); } void diff --git a/src/migration/MigratiorStatus.hpp b/src/migration/MigratiorStatus.hpp index b36c8d079..821d6bb1a 100644 --- a/src/migration/MigratiorStatus.hpp +++ b/src/migration/MigratiorStatus.hpp @@ -62,7 +62,7 @@ public: private: static constexpr std::array(Status::NumStatuses)> - kSTATUS_STR_MAP = {"Migrated", "NotMigrated", "NotKnown"}; + kStatusStrMap = {"Migrated", "NotMigrated", "NotKnown"}; Status status_; }; diff --git a/src/migration/MigratorStatus.cpp b/src/migration/MigratorStatus.cpp index ff0b96a50..8d916b6fb 100644 --- a/src/migration/MigratorStatus.cpp +++ b/src/migration/MigratorStatus.cpp @@ -20,14 +20,14 @@ MigratorStatus::operator==(Status const& other) const std::string MigratorStatus::toString() const { - return kSTATUS_STR_MAP[static_cast(status_)]; + return kStatusStrMap[static_cast(status_)]; } MigratorStatus MigratorStatus::fromString(std::string const& statusStr) { - for (std::size_t i = 0; i < kSTATUS_STR_MAP.size(); ++i) { - if (statusStr == kSTATUS_STR_MAP[i]) { + for (std::size_t i = 0; i < kStatusStrMap.size(); ++i) { + if (statusStr == kStatusStrMap[i]) { return MigratorStatus(static_cast(i)); } } diff --git a/src/migration/README.md b/src/migration/README.md index 93ace4197..580b53433 100644 --- a/src/migration/README.md +++ b/src/migration/README.md @@ -34,11 +34,11 @@ A migrator satisfies the `MigratorSpec`(impl/Spec.hpp) concept. It contains: -- A `kNAME` which will be used to identify the migrator. User will refer this migrator in command-line tool by this name. The name needs to be different with other migrators, otherwise a compilation error will be raised. +- A `kName` which will be used to identify the migrator. User will refer this migrator in command-line tool by this name. The name needs to be different with other migrators, otherwise a compilation error will be raised. -- A `kDESCRIPTION` which is the detail information of the migrator. +- A `kDescription` which is the detail information of the migrator. -- An optional `kCAN_BLOCK_CLIO` which indicates whether the migrator can block the Clio server. If it's absent, the migrator can't block server. If there is a blocking migrator not completed, the Clio server will fail to start. +- An optional `kCanBlockClio` which indicates whether the migrator can block the Clio server. If it's absent, the migrator can't block server. If there is a blocking migrator not completed, the Clio server will fail to start. - A static function `runMigration`, it will be called when user run `--migrate name`. It accepts two parameters: backend, which provides the DB operations interface, and cfg, which provides migration-related configuration. Each migrator can have its own configuration under `.migration` session. @@ -63,8 +63,8 @@ If you need to do full scan against other table, you can follow below steps: - Describe the table which needs full scan in a struct. It has to satisfy the `TableSpec`(cassandra/Spec.hpp) concept, containing static member: - Tuple type `Row`, it's the type of each field in a row. The order of types should match what database will return in a row. Key types should come first, followed by other field types sorted in alphabetical order. - - `kPARTITION_KEY`, it's the name of the partition key of the table. - - `kTABLE_NAME` + - `kPartitionKey`, it's the name of the partition key of the table. + - `kTableName` - Inherent from `FullTableScannerAdapterBase`. - Implement `onRowRead`, its parameter is the `Row` we defined. It's the callback function when a row is read. diff --git a/src/migration/cassandra/CassandraMigrationBackend.hpp b/src/migration/cassandra/CassandraMigrationBackend.hpp index 2930b8de9..33a15f474 100644 --- a/src/migration/cassandra/CassandraMigrationBackend.hpp +++ b/src/migration/cassandra/CassandraMigrationBackend.hpp @@ -60,24 +60,24 @@ public: ) { LOG(log_.debug()) << "Travsering token range: " << start << " - " << end - << " ; table: " << TableDesc::kTABLE_NAME; + << " ; table: " << TableDesc::kTableName; // for each table we only have one prepared statement - static auto kSTATEMENT_PREPARED = migrationSchema_.getPreparedFullScanStatement( - handle_, TableDesc::kTABLE_NAME, TableDesc::kPARTITION_KEY + static auto kStatementPrepared = migrationSchema_.getPreparedFullScanStatement( + handle_, TableDesc::kTableName, TableDesc::kPartitionKey ); - auto const statement = kSTATEMENT_PREPARED.bind(start, end); + auto const statement = kStatementPrepared.bind(start, end); auto const res = this->executor_.read(yield, statement); if (not res) { - LOG(log_.error()) << "Could not fetch data from table: " << TableDesc::kTABLE_NAME + LOG(log_.error()) << "Could not fetch data from table: " << TableDesc::kTableName << " range: " << start << " - " << end << ";" << res.error(); return; } auto const& results = res.value(); if (not results.hasRows()) { - LOG(log_.debug()) << "No rows returned - table: " << TableDesc::kTABLE_NAME + LOG(log_.debug()) << "No rows returned - table: " << TableDesc::kTableName << " range: " << start << " - " << end; return; } diff --git a/src/migration/cassandra/impl/CassandraMigrationSchema.hpp b/src/migration/cassandra/impl/CassandraMigrationSchema.hpp index 7ec85ee19..eb1bbb9f9 100644 --- a/src/migration/cassandra/impl/CassandraMigrationSchema.hpp +++ b/src/migration/cassandra/impl/CassandraMigrationSchema.hpp @@ -71,7 +71,7 @@ public: data::cassandra::PreparedStatement const& getPreparedInsertMigratedMigrator(data::cassandra::Handle const& handler) { - static auto kPREPARED = handler.prepare( + static auto kPrepared = handler.prepare( fmt::format( R"( INSERT INTO {} @@ -83,7 +83,7 @@ public: ) ) ); - return kPREPARED; + return kPrepared; } }; } // namespace migration::cassandra::impl diff --git a/src/migration/cassandra/impl/ObjectsAdapter.hpp b/src/migration/cassandra/impl/ObjectsAdapter.hpp index c8db88e66..8039c474a 100644 --- a/src/migration/cassandra/impl/ObjectsAdapter.hpp +++ b/src/migration/cassandra/impl/ObjectsAdapter.hpp @@ -23,8 +23,8 @@ namespace migration::cassandra::impl { */ struct TableObjectsDesc { using Row = std::tuple; - static constexpr char const* kPARTITION_KEY = "key"; - static constexpr char const* kTABLE_NAME = "objects"; + static constexpr char const* kPartitionKey = "key"; + static constexpr char const* kTableName = "objects"; }; /** diff --git a/src/migration/cassandra/impl/Spec.hpp b/src/migration/cassandra/impl/Spec.hpp index 9daa12bc9..6e6426347 100644 --- a/src/migration/cassandra/impl/Spec.hpp +++ b/src/migration/cassandra/impl/Spec.hpp @@ -16,7 +16,7 @@ concept TableSpec = requires { requires std::tuple_size_v >= 0; // Ensures 'row' is a tuple // Check that static constexpr members 'partitionKey' and 'tableName' exist - { T::kPARTITION_KEY } -> std::convertible_to; - { T::kTABLE_NAME } -> std::convertible_to; + { T::kPartitionKey } -> std::convertible_to; + { T::kTableName } -> std::convertible_to; }; } // namespace migration::cassandra::impl diff --git a/src/migration/cassandra/impl/TransactionsAdapter.hpp b/src/migration/cassandra/impl/TransactionsAdapter.hpp index 928e25862..0e784414d 100644 --- a/src/migration/cassandra/impl/TransactionsAdapter.hpp +++ b/src/migration/cassandra/impl/TransactionsAdapter.hpp @@ -24,8 +24,8 @@ struct TableTransactionsDesc { // hash, date, ledger_seq, metadata, transaction using Row = std::tuple; - static constexpr char const* kPARTITION_KEY = "hash"; - static constexpr char const* kTABLE_NAME = "transactions"; + static constexpr char const* kPartitionKey = "hash"; + static constexpr char const* kTableName = "transactions"; }; /** diff --git a/src/migration/impl/MigratorsRegister.hpp b/src/migration/impl/MigratorsRegister.hpp index 4f02910dc..b447e99dd 100644 --- a/src/migration/impl/MigratorsRegister.hpp +++ b/src/migration/impl/MigratorsRegister.hpp @@ -34,7 +34,7 @@ concept BackendMatchAllMigrators = (MigrationBackend && . template concept HasCanBlockClio = requires(T t) { - { t.kCAN_BLOCK_CLIO }; + { t.kCanBlockClio }; }; /** @@ -57,7 +57,7 @@ class MigratorsRegister { void callMigration(std::string const& name, util::config::ObjectView const& config) { - if (name == Migrator::kNAME) { + if (name == Migrator::kName) { LOG(log_.info()) << "Running migration: " << name; Migrator::runMigration(backend_, config); backend_->writeMigratorStatus( @@ -71,16 +71,16 @@ class MigratorsRegister { static constexpr std::string_view getDescriptionIfMatch(std::string_view targetName) { - return (T::kNAME == targetName) ? T::kDESCRIPTION : ""; + return (T::kName == targetName) ? T::kDescription : ""; } template static constexpr bool canBlockClioHelper(std::string_view targetName) { - if (targetName == First::kNAME) { + if (targetName == First::kName) { if constexpr (HasCanBlockClio) { - return First::kCAN_BLOCK_CLIO; + return First::kCanBlockClio; } return false; } @@ -168,7 +168,7 @@ public: [[nodiscard]] constexpr auto getMigratorNames() const { - return std::array{MigratorType::kNAME...}; + return std::array{MigratorType::kName...}; } /** diff --git a/src/migration/impl/Spec.hpp b/src/migration/impl/Spec.hpp index b41c9b7eb..28aafeeb9 100644 --- a/src/migration/impl/Spec.hpp +++ b/src/migration/impl/Spec.hpp @@ -15,11 +15,11 @@ namespace migration::impl { template concept MigratorSpec = requires(std::shared_ptr const& backend, util::config::ObjectView const& cfg) { - // Check that 'kNAME' exists and is a string - { T::kNAME } -> std::convertible_to; + // Check that 'kName' exists and is a string + { T::kName } -> std::convertible_to; - // Check that 'kDESCRIPTION' exists and is a string - { T::kDESCRIPTION } -> std::convertible_to; + // Check that 'kDescription' exists and is a string + { T::kDescription } -> std::convertible_to; // Check that the migrator specifies the backend type it supports typename T::Backend; diff --git a/src/rpc/Errors.cpp b/src/rpc/Errors.cpp index 393d77aae..5d7da425f 100644 --- a/src/rpc/Errors.cpp +++ b/src/rpc/Errors.cpp @@ -60,7 +60,7 @@ operator<<(std::ostream& stream, Status const& status) WarningInfo const& getWarningInfo(WarningCode code) { - static constexpr WarningInfo kINFOS[]{ + static constexpr WarningInfo kInfos[]{ {WarningCode::WarnUnknown, "Unknown warning"}, {WarningCode::WarnRpcClio, "This is a clio server. clio only serves validated data. If you want to talk to rippled, " @@ -74,7 +74,7 @@ getWarningInfo(WarningCode code) }; auto matchByCode = [code](auto const& info) { return info.code == code; }; - if (auto it = ranges::find_if(kINFOS, matchByCode); it != end(kINFOS)) + if (auto it = ranges::find_if(kInfos, matchByCode); it != end(kInfos)) return *it; throw(out_of_range("Invalid WarningCode")); @@ -93,7 +93,7 @@ makeWarning(WarningCode code) ClioErrorInfo const& getErrorInfo(ClioError code) { - static constexpr ClioErrorInfo kINFOS[]{ + static constexpr ClioErrorInfo kInfos[]{ {.code = ClioError::RpcMalformedCurrency, .error = "malformedCurrency", .message = "Malformed currency."}, @@ -150,7 +150,7 @@ getErrorInfo(ClioError code) }; auto matchByCode = [code](auto const& info) { return info.code == code; }; - if (auto it = ranges::find_if(kINFOS, matchByCode); it != end(kINFOS)) + if (auto it = ranges::find_if(kInfos, matchByCode); it != end(kInfos)) return *it; throw(out_of_range("Invalid error code")); diff --git a/src/rpc/RPCCenter.cpp b/src/rpc/RPCCenter.cpp index 0ed3ff875..8280ded91 100644 --- a/src/rpc/RPCCenter.cpp +++ b/src/rpc/RPCCenter.cpp @@ -10,7 +10,7 @@ namespace { std::unordered_set const& handledRpcs() { - static std::unordered_set const kHANDLED_RPCS = { + static std::unordered_set const kHandledRpcs = { // clang-format off "account_channels", "account_currencies", @@ -52,13 +52,13 @@ handledRpcs() "version", // clang-format on }; - return kHANDLED_RPCS; + return kHandledRpcs; } std::unordered_set const& forwardedRpcs() { - static std::unordered_set const kFORWARDED_RPCS = { + static std::unordered_set const kForwardedRpcs = { "server_definitions", "server_state", "submit", @@ -73,7 +73,7 @@ forwardedRpcs() "simulate", "batch" }; - return kFORWARDED_RPCS; + return kForwardedRpcs; } } // namespace diff --git a/src/rpc/RPCHelpers.cpp b/src/rpc/RPCHelpers.cpp index 5a389f7e2..d447e5d4a 100644 --- a/src/rpc/RPCHelpers.cpp +++ b/src/rpc/RPCHelpers.cpp @@ -135,10 +135,9 @@ getDeliveredAmount( // then its absence indicates that the amount delivered is listed in the // Amount field. DeliveredAmount went live January 24, 2014. // 446000000 is in Feb 2014, well after DeliveredAmount went live - static constexpr std::uint32_t kFIRST_LEDGER_WITH_DELIVERED_AMOUNT = 4594095; - static constexpr std::uint32_t kDELIVERED_AMOUNT_LIVE_DATE = 446000000; - if (ledgerSequence >= kFIRST_LEDGER_WITH_DELIVERED_AMOUNT || - date > kDELIVERED_AMOUNT_LIVE_DATE) { + static constexpr std::uint32_t kFirstLedgerWithDeliveredAmount = 4594095; + static constexpr std::uint32_t kDeliveredAmountLiveDate = 446000000; + if (ledgerSequence >= kFirstLedgerWithDeliveredAmount || date > kDeliveredAmountLiveDate) { return txn->getFieldAmount(ripple::sfAmount); } } @@ -270,15 +269,15 @@ toExpandedJson( std::optional encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint16_t networkId) noexcept { - static constexpr uint32_t kMAX_LEDGER_SEQ = 0x0FFF'FFFF; - static constexpr uint32_t kMAX_TXN_INDEX = 0xFFFF; - static constexpr uint32_t kMAX_NETWORK_ID = 0xFFFF; + static constexpr uint32_t kMaxLedgerSeq = 0x0FFF'FFFF; + static constexpr uint32_t kMaxTxnIndex = 0xFFFF; + static constexpr uint32_t kMaxNetworkId = 0xFFFF; - if (ledgerSeq > kMAX_LEDGER_SEQ || txnIndex > kMAX_TXN_INDEX || networkId > kMAX_NETWORK_ID) + if (ledgerSeq > kMaxLedgerSeq || txnIndex > kMaxTxnIndex || networkId > kMaxNetworkId) return {}; - static constexpr uint64_t kCTID_PREFIX = 0xC000'0000; - uint64_t const ctidValue = ((kCTID_PREFIX + static_cast(ledgerSeq)) << 32) + + static constexpr uint64_t kCtidPrefix = 0xC000'0000; + uint64_t const ctidValue = ((kCtidPrefix + static_cast(ledgerSeq)) << 32) + (static_cast(txnIndex) << 16) + networkId; return {fmt::format("{:016X}", ctidValue)}; @@ -731,8 +730,8 @@ traverseOwnedNodes( // Only reserve 2048 nodes when fetching all owned ledger objects. If there // are more, then keys will allocate more memory, which is suboptimal, but // should only occur occasionally. - static constexpr std::uint32_t kMIN_NODES = 2048; - keys.reserve(std::min(kMIN_NODES, limit)); + static constexpr std::uint32_t kMinNodes = 2048; + keys.reserve(std::min(kMinNodes, limit)); auto start = std::chrono::system_clock::now(); @@ -879,10 +878,10 @@ parseRippleLibSeed(boost::json::value const& value) boost::json::value_to(value), ripple::TokenType::None ); - static constexpr std::size_t kSEED_SIZE = 18; - static constexpr std::array kSEED_PREFIX = {0xE1, 0x4B}; - if (result.size() == kSEED_SIZE && static_cast(result[0]) == kSEED_PREFIX[0] && - static_cast(result[1]) == kSEED_PREFIX[1]) + static constexpr std::size_t kSeedSize = 18; + static constexpr std::array kSeedPrefix = {0xE1, 0x4B}; + if (result.size() == kSeedSize && static_cast(result[0]) == kSeedPrefix[0] && + static_cast(result[1]) == kSeedPrefix[1]) return ripple::Seed(ripple::makeSlice(result.substr(2))); return {}; diff --git a/src/rpc/RPCHelpers.hpp b/src/rpc/RPCHelpers.hpp index 231513c35..6cac45430 100644 --- a/src/rpc/RPCHelpers.hpp +++ b/src/rpc/RPCHelpers.hpp @@ -713,8 +713,8 @@ decodeCTID(T const ctid) noexcept auto const getCTID64 = [](T const ctid) noexcept -> std::optional { if constexpr (std::is_convertible_v) { std::string const ctidString(ctid); - static constexpr std::size_t kCTID_STRING_LENGTH = 16; - if (ctidString.length() != kCTID_STRING_LENGTH) + static constexpr std::size_t kCtidStringLength = 16; + if (ctidString.length() != kCtidStringLength) return {}; if (!boost::regex_match(ctidString, boost::regex("^[0-9A-F]+$"))) @@ -731,10 +731,10 @@ decodeCTID(T const ctid) noexcept auto const ctidValue = getCTID64(ctid).value_or(0); - static constexpr uint64_t kCTID_PREFIX = 0xC000'0000'0000'0000ULL; - static constexpr uint64_t kCTID_PREFIX_MASK = 0xF000'0000'0000'0000ULL; + static constexpr uint64_t kCtidPrefix = 0xC000'0000'0000'0000ULL; + static constexpr uint64_t kCtidPrefixMask = 0xF000'0000'0000'0000ULL; - if ((ctidValue & kCTID_PREFIX_MASK) != kCTID_PREFIX) + if ((ctidValue & kCtidPrefixMask) != kCtidPrefix) return {}; uint32_t const ledgerSeq = (ctidValue >> 32) & 0xFFFF'FFFUL; @@ -762,7 +762,7 @@ logDuration( using boost::json::serialize; static util::Logger const log{"RPC"}; // NOLINT(readability-identifier-naming) - static constexpr std::int64_t kDURATION_ERROR_THRESHOLD_SECONDS = 10; + static constexpr std::int64_t kDurationErrorThresholdSeconds = 10; auto const millis = std::chrono::duration_cast(dur).count(); auto const seconds = std::chrono::duration_cast(dur).count(); @@ -772,7 +772,7 @@ logDuration( serialize(util::removeSecret(request)) ); - if (seconds > kDURATION_ERROR_THRESHOLD_SECONDS) { + if (seconds > kDurationErrorThresholdSeconds) { LOG(log.error()) << tag << msg; } else if (seconds > 1) { LOG(log.warn()) << tag << msg; diff --git a/src/rpc/WorkQueue.cpp b/src/rpc/WorkQueue.cpp index 89a72872d..02dc8e4ad 100644 --- a/src/rpc/WorkQueue.cpp +++ b/src/rpc/WorkQueue.cpp @@ -62,7 +62,7 @@ WorkQueue::WorkQueue(DontStartProcessingTag, std::uint32_t numWorkers, uint32_t } WorkQueue::WorkQueue(std::uint32_t numWorkers, uint32_t maxSize) - : WorkQueue(kDONT_START_PROCESSING_TAG, numWorkers, maxSize) + : WorkQueue(kDontStartProcessingTag, numWorkers, maxSize) { startProcessing(); } diff --git a/src/rpc/WorkQueue.hpp b/src/rpc/WorkQueue.hpp index 8a6483275..bf99f2e5f 100644 --- a/src/rpc/WorkQueue.hpp +++ b/src/rpc/WorkQueue.hpp @@ -90,7 +90,7 @@ private: [[nodiscard]] std::optional popNext() { - if (not high.empty() and (highPriorityCounter < kTAKE_HIGH_PRIO or normal.empty())) { + if (not high.empty() and (highPriorityCounter < kTakeHighPrio or normal.empty())) { auto taskWithTimestamp = std::move(high.front()); high.pop(); ++highPriorityCounter; @@ -109,7 +109,7 @@ private: }; private: - static constexpr auto kTAKE_HIGH_PRIO = 4uz; + static constexpr auto kTakeHighPrio = 4uz; // these are cumulative for the lifetime of the process std::reference_wrapper queued_; @@ -143,7 +143,7 @@ private: public: struct DontStartProcessingTag {}; - static constexpr DontStartProcessingTag kDONT_START_PROCESSING_TAG = {}; + static constexpr DontStartProcessingTag kDontStartProcessingTag = {}; /** * @brief Create an instance of the work queue. diff --git a/src/rpc/common/APIVersion.hpp b/src/rpc/common/APIVersion.hpp index faca665a4..bbf65b48f 100644 --- a/src/rpc/common/APIVersion.hpp +++ b/src/rpc/common/APIVersion.hpp @@ -11,17 +11,17 @@ namespace rpc { /** * @brief Default API version to use if no version is specified by clients */ -static constexpr uint32_t kAPI_VERSION_DEFAULT = 1u; +static constexpr uint32_t kApiVersionDefault = 1u; /** * @brief Minimum API version supported by this build */ -static constexpr uint32_t kAPI_VERSION_MIN = 1u; +static constexpr uint32_t kApiVersionMin = 1u; /** * @brief Maximum API version supported by this build */ -static constexpr uint32_t kAPI_VERSION_MAX = 3u; +static constexpr uint32_t kApiVersionMax = 3u; /** * @brief A baseclass for API version helper diff --git a/src/rpc/common/Specs.hpp b/src/rpc/common/Specs.hpp index 36da6b0c6..f3996da37 100644 --- a/src/rpc/common/Specs.hpp +++ b/src/rpc/common/Specs.hpp @@ -32,7 +32,7 @@ struct FieldSpec final { : processor_{ impl::makeFieldProcessor(key, std::forward(processors)...) } - , checker_{impl::kEMPTY_FIELD_CHECKER} + , checker_{impl::kEmptyFieldChecker} { } @@ -45,7 +45,7 @@ struct FieldSpec final { */ template FieldSpec(std::string const& key, Checks&&... checks) - : processor_{impl::kEMPTY_FIELD_PROCESSOR} + : processor_{impl::kEmptyFieldProcessor} , checker_{impl::makeFieldChecker(key, std::forward(checks)...)} { } diff --git a/src/rpc/common/Validators.cpp b/src/rpc/common/Validators.cpp index a745bf342..cb83f2aa7 100644 --- a/src/rpc/common/Validators.cpp +++ b/src/rpc/common/Validators.cpp @@ -232,7 +232,7 @@ CustomValidator CustomValidators::subscribeStreamValidator = if (!value.is_array()) return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotArray"}}; - static std::unordered_set const kVALID_STREAMS = { + static std::unordered_set const kValidStreams = { "ledger", "transactions", "transactions_proposed", @@ -241,17 +241,17 @@ CustomValidator CustomValidators::subscribeStreamValidator = "validations" }; - static std::unordered_set const kNOT_SUPPORT_STREAMS = { + static std::unordered_set const kNotSupportStreams = { "peer_status", "consensus", "server" }; for (auto const& v : value.as_array()) { if (!v.is_string()) return Error{Status{RippledError::rpcINVALID_PARAMS, "streamNotString"}}; - if (kNOT_SUPPORT_STREAMS.contains(boost::json::value_to(v))) + if (kNotSupportStreams.contains(boost::json::value_to(v))) return Error{Status{RippledError::rpcNOT_SUPPORTED}}; - if (not kVALID_STREAMS.contains(boost::json::value_to(v))) + if (not kValidStreams.contains(boost::json::value_to(v))) return Error{Status{RippledError::rpcSTREAM_MALFORMED}}; } diff --git a/src/rpc/common/impl/APIVersionParser.hpp b/src/rpc/common/impl/APIVersionParser.hpp index 4edbf4cf7..88cbce838 100644 --- a/src/rpc/common/impl/APIVersionParser.hpp +++ b/src/rpc/common/impl/APIVersionParser.hpp @@ -21,9 +21,9 @@ class ProductionAPIVersionParser : public APIVersionParser { public: ProductionAPIVersionParser( - uint32_t defaultVersion = kAPI_VERSION_DEFAULT, - uint32_t minVersion = kAPI_VERSION_MIN, - uint32_t maxVersion = kAPI_VERSION_MAX + uint32_t defaultVersion = kApiVersionDefault, + uint32_t minVersion = kApiVersionMin, + uint32_t maxVersion = kApiVersionMax ); ProductionAPIVersionParser(util::config::ObjectView const& config); diff --git a/src/rpc/common/impl/Factories.hpp b/src/rpc/common/impl/Factories.hpp index b0b107984..9980178fd 100644 --- a/src/rpc/common/impl/Factories.hpp +++ b/src/rpc/common/impl/Factories.hpp @@ -20,7 +20,7 @@ namespace rpc::impl { using FieldSpecProcessor = std::function; -static FieldSpecProcessor const kEMPTY_FIELD_PROCESSOR = [](boost::json::value&) -> MaybeError { +static FieldSpecProcessor const kEmptyFieldProcessor = [](boost::json::value&) -> MaybeError { return {}; }; @@ -60,7 +60,7 @@ makeFieldProcessor(std::string const& key, Processors&&... procs) using FieldChecker = std::function; -static FieldChecker const kEMPTY_FIELD_CHECKER = [](boost::json::value const&) -> check::Warnings { +static FieldChecker const kEmptyFieldChecker = [](boost::json::value const&) -> check::Warnings { return {}; }; diff --git a/src/rpc/common/impl/ForwardingProxy.hpp b/src/rpc/common/impl/ForwardingProxy.hpp index 29d06d727..ee29ec013 100644 --- a/src/rpc/common/impl/ForwardingProxy.hpp +++ b/src/rpc/common/impl/ForwardingProxy.hpp @@ -115,9 +115,9 @@ private: [[nodiscard]] bool isForcedForward(web::Context const& ctx) const { - static constexpr auto kFORCE_FORWARD = "force_forward"; - return ctx.isAdmin and ctx.params.contains(kFORCE_FORWARD) and - ctx.params.at(kFORCE_FORWARD).is_bool() and ctx.params.at(kFORCE_FORWARD).as_bool(); + static constexpr auto kForceForward = "force_forward"; + return ctx.isAdmin and ctx.params.contains(kForceForward) and + ctx.params.at(kForceForward).is_bool() and ctx.params.at(kForceForward).as_bool(); } }; diff --git a/src/rpc/handlers/AMMInfo.cpp b/src/rpc/handlers/AMMInfo.cpp index 08c19082b..ddd989f02 100644 --- a/src/rpc/handlers/AMMInfo.cpp +++ b/src/rpc/handlers/AMMInfo.cpp @@ -46,12 +46,12 @@ std::string toIso8601(ripple::NetClock::time_point tp) { using namespace std::chrono; - static constexpr auto kRIPPLE_EPOCH_OFFSET = seconds{kRIPPLE_EPOCH_START}; + static constexpr auto kRippleEpochOffset = seconds{kRippleEpochStart}; return date::format( "%Y-%Om-%dT%H:%M:%OS%z", date::sys_time( - system_clock::time_point{tp.time_since_epoch() + kRIPPLE_EPOCH_OFFSET} + system_clock::time_point{tp.time_since_epoch() + kRippleEpochOffset} ) ); }; @@ -230,7 +230,7 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) RpcSpecConstRef AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kSTRING_ISSUE_VALIDATOR = validation::CustomValidator{ + static auto const kStringIssueValidator = validation::CustomValidator{ [](boost::json::value const& value, std::string_view key) -> MaybeError { if (not value.is_string()) { return Error{ @@ -248,7 +248,7 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) } }; - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(asset), @@ -256,7 +256,7 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) validation::Type{}, Status(RippledError::rpcISSUE_MALFORMED) }, - meta::IfType{kSTRING_ISSUE_VALIDATOR}, + meta::IfType{kStringIssueValidator}, meta::IfType{ meta::WithCustomError{ validation::CustomValidators::currencyIssueValidator, @@ -268,7 +268,7 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) validation::Type{}, Status(RippledError::rpcISSUE_MALFORMED) }, - meta::IfType{kSTRING_ISSUE_VALIDATOR}, + meta::IfType{kStringIssueValidator}, meta::IfType{ meta::WithCustomError{ validation::CustomValidators::currencyIssueValidator, @@ -285,7 +285,7 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) }}, }; - return kRPC_SPEC; + return kRpcSpec; } void diff --git a/src/rpc/handlers/AccountChannels.hpp b/src/rpc/handlers/AccountChannels.hpp index 07a197f64..c16f5ed7f 100644 --- a/src/rpc/handlers/AccountChannels.hpp +++ b/src/rpc/handlers/AccountChannels.hpp @@ -32,9 +32,9 @@ class AccountChannelsHandler { std::shared_ptr const sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 10; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 10; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold data for one channel response @@ -78,7 +78,7 @@ public: std::optional destinationAccount; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional marker; }; @@ -103,7 +103,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(destination_account), validation::Type{}, @@ -112,12 +112,12 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(marker), validation::CustomValidators::accountMarkerValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountCurrencies.hpp b/src/rpc/handlers/AccountCurrencies.hpp index 91ca3a053..f8e4441f2 100644 --- a/src/rpc/handlers/AccountCurrencies.hpp +++ b/src/rpc/handlers/AccountCurrencies.hpp @@ -72,7 +72,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, @@ -80,7 +80,7 @@ public: {JS(strict), check::Deprecated{}} }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountInfo.hpp b/src/rpc/handlers/AccountInfo.hpp index 84e3c3e51..f2ef292e2 100644 --- a/src/rpc/handlers/AccountInfo.hpp +++ b/src/rpc/handlers/AccountInfo.hpp @@ -88,7 +88,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC_V1 = RpcSpec{ + static auto const kRpcSpecV1 = RpcSpec{ {JS(account), validation::CustomValidators::accountValidator}, {JS(ident), validation::CustomValidators::accountValidator}, {JS(ident), check::Deprecated{}}, @@ -98,10 +98,10 @@ public: {JS(strict), check::Deprecated{}} }; - static auto const kRPC_SPEC = - RpcSpec{kRPC_SPEC_V1, {{JS(signer_lists), validation::Type{}}}}; + static auto const kRpcSpec = + RpcSpec{kRpcSpecV1, {{JS(signer_lists), validation::Type{}}}}; - return apiVersion == 1 ? kRPC_SPEC_V1 : kRPC_SPEC; + return apiVersion == 1 ? kRpcSpecV1 : kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountLines.hpp b/src/rpc/handlers/AccountLines.hpp index 0cd3384e0..4a6d00fae 100644 --- a/src/rpc/handlers/AccountLines.hpp +++ b/src/rpc/handlers/AccountLines.hpp @@ -36,9 +36,9 @@ class AccountLinesHandler { std::shared_ptr const sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 10; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 10; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold data for one line response @@ -84,7 +84,7 @@ public: std::optional peer; bool ignoreDefault = false; // TODO: document // https://github.com/XRPLF/xrpl-dev-portal/issues/1839 - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional marker; }; @@ -109,7 +109,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, meta::WithCustomError{ @@ -126,14 +126,14 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(marker), validation::CustomValidators::accountMarkerValidator}, {JS(ledger), check::Deprecated{}}, {"peer_index", check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountMPTokenIssuances.hpp b/src/rpc/handlers/AccountMPTokenIssuances.hpp index 53ec3c5bf..deca986d4 100644 --- a/src/rpc/handlers/AccountMPTokenIssuances.hpp +++ b/src/rpc/handlers/AccountMPTokenIssuances.hpp @@ -34,9 +34,9 @@ class AccountMPTokenIssuancesHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 10; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 10; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold data for one MPTokenIssuance response. @@ -93,7 +93,7 @@ public: std::string account; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional marker; }; @@ -118,7 +118,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, meta::WithCustomError{ @@ -129,13 +129,13 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(marker), validation::CustomValidators::accountMarkerValidator}, {JS(ledger), check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountMPTokens.hpp b/src/rpc/handlers/AccountMPTokens.hpp index 92338b37f..c00e62d7e 100644 --- a/src/rpc/handlers/AccountMPTokens.hpp +++ b/src/rpc/handlers/AccountMPTokens.hpp @@ -33,9 +33,9 @@ class AccountMPTokensHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 10; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 10; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold data for one MPToken response. @@ -71,7 +71,7 @@ public: std::string account; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional marker; }; @@ -96,7 +96,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, meta::WithCustomError{ @@ -107,13 +107,13 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(marker), validation::CustomValidators::accountMarkerValidator}, {JS(ledger), check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountNFTs.hpp b/src/rpc/handlers/AccountNFTs.hpp index 79b10a6c1..dcea64578 100644 --- a/src/rpc/handlers/AccountNFTs.hpp +++ b/src/rpc/handlers/AccountNFTs.hpp @@ -28,9 +28,9 @@ class AccountNFTsHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 20; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 100; + static constexpr auto kLimitMin = 20; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 100; /** * @brief A struct to hold the output data of the command @@ -53,7 +53,7 @@ public: std::string account; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; // Limit the number of token pages to retrieve. [20,400] + uint32_t limit = kLimitDefault; // Limit the number of token pages to retrieve. [20,400] std::optional marker; }; @@ -78,7 +78,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, @@ -86,10 +86,10 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountObjects.hpp b/src/rpc/handlers/AccountObjects.hpp index 5271d3f3a..46b855812 100644 --- a/src/rpc/handlers/AccountObjects.hpp +++ b/src/rpc/handlers/AccountObjects.hpp @@ -34,9 +34,9 @@ class AccountObjectsHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 10; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 10; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold the output data of the command @@ -58,7 +58,7 @@ public: std::string account; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; // [10,400] + uint32_t limit = kLimitDefault; // [10,400] std::optional marker; std::optional type; bool deletionBlockersOnly = false; @@ -85,20 +85,20 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp(kLIMIT_MIN, kLIMIT_MAX)}, + modifiers::Clamp(kLimitMin, kLimitMax)}, {JS(type), validation::CustomValidators::accountTypeValidator}, {JS(marker), validation::CustomValidators::accountMarkerValidator}, {JS(deletion_blockers_only), validation::Type{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountOffers.hpp b/src/rpc/handlers/AccountOffers.hpp index a4bb11719..07506846b 100644 --- a/src/rpc/handlers/AccountOffers.hpp +++ b/src/rpc/handlers/AccountOffers.hpp @@ -31,9 +31,9 @@ class AccountOffersHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 10; - static constexpr auto kLIMIT_MAX = 400; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 10; + static constexpr auto kLimitMax = 400; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold data for one offer response @@ -67,7 +67,7 @@ public: std::string account; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional marker; }; @@ -92,7 +92,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, @@ -100,12 +100,12 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(ledger), check::Deprecated{}}, {JS(strict), check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/AccountTx.cpp b/src/rpc/handlers/AccountTx.cpp index 70f52217f..de28825c1 100644 --- a/src/rpc/handlers/AccountTx.cpp +++ b/src/rpc/handlers/AccountTx.cpp @@ -113,7 +113,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c } } - auto const limit = input.limit.value_or(kLIMIT_DEFAULT); + auto const limit = input.limit.value_or(kLimitDefault); auto const accountID = accountFromStringStrict(input.account); auto const [txnsAndCursor, timeDiff] = util::timed([&]() { return sharedPtrBackend_->fetchAccountTransactions( diff --git a/src/rpc/handlers/AccountTx.hpp b/src/rpc/handlers/AccountTx.hpp index 10df1a3a6..bfb579469 100644 --- a/src/rpc/handlers/AccountTx.hpp +++ b/src/rpc/handlers/AccountTx.hpp @@ -41,9 +41,9 @@ class AccountTxHandler { std::shared_ptr etl_; public: - static constexpr auto kLIMIT_MIN = 1; - static constexpr auto kLIMIT_MAX = 1000; - static constexpr auto kLIMIT_DEFAULT = 200; + static constexpr auto kLimitMin = 1; + static constexpr auto kLimitMax = 1000; + static constexpr auto kLimitDefault = 200; /** * @brief A struct to hold the marker data @@ -113,7 +113,7 @@ public: spec([[maybe_unused]] uint32_t apiVersion) { auto const& typesKeysInLowercase = util::getTxTypesInLowercase(); - static auto const kRPC_SPEC_FOR_V1 = RpcSpec{ + static auto const kRpcSpecForV1 = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, @@ -123,7 +123,7 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(marker), meta::WithCustomError{ validation::Type{}, @@ -143,15 +143,15 @@ public: }, }; - static auto const kRPC_SPEC = RpcSpec{ - kRPC_SPEC_FOR_V1, + static auto const kRpcSpec = RpcSpec{ + kRpcSpecForV1, { {JS(binary), validation::Type{}}, {JS(forward), validation::Type{}}, } }; - return apiVersion == 1 ? kRPC_SPEC_FOR_V1 : kRPC_SPEC; + return apiVersion == 1 ? kRpcSpecForV1 : kRpcSpec; } /** diff --git a/src/rpc/handlers/BookChanges.hpp b/src/rpc/handlers/BookChanges.hpp index 5abf22e93..e82c5a0ce 100644 --- a/src/rpc/handlers/BookChanges.hpp +++ b/src/rpc/handlers/BookChanges.hpp @@ -70,12 +70,12 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/BookOffers.hpp b/src/rpc/handlers/BookOffers.hpp index b974d6420..597ae77d5 100644 --- a/src/rpc/handlers/BookOffers.hpp +++ b/src/rpc/handlers/BookOffers.hpp @@ -37,9 +37,9 @@ class BookOffersHandler { std::shared_ptr amendmentCenter_; public: - static constexpr auto kLIMIT_MIN = 1; - static constexpr auto kLIMIT_MAX = 100; - static constexpr auto kLIMIT_DEFAULT = 60; + static constexpr auto kLimitMin = 1; + static constexpr auto kLimitMax = 100; + static constexpr auto kLimitDefault = 60; /** * @brief A struct to hold the output data of the command @@ -60,7 +60,7 @@ public: struct Input { std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional taker; ripple::Currency paysCurrency; ripple::Currency getsCurrency; @@ -95,7 +95,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(taker_gets), validation::Required{}, validation::Type{}, @@ -146,12 +146,12 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/DepositAuthorized.hpp b/src/rpc/handlers/DepositAuthorized.hpp index a0db152d2..20999738c 100644 --- a/src/rpc/handlers/DepositAuthorized.hpp +++ b/src/rpc/handlers/DepositAuthorized.hpp @@ -81,7 +81,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(source_account), validation::Required{}, validation::CustomValidators::accountValidator}, @@ -93,7 +93,7 @@ public: {JS(credentials), validation::Type{}, validation::Hex256ItemType()} }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/Feature.cpp b/src/rpc/handlers/Feature.cpp index e3098e994..6031dbbf8 100644 --- a/src/rpc/handlers/Feature.cpp +++ b/src/rpc/handlers/Feature.cpp @@ -102,7 +102,7 @@ FeatureHandler::process(FeatureHandler::Input const& input, Context const& ctx) RpcSpecConstRef FeatureHandler::spec([[maybe_unused]] uint32_t apiVersion) { - static RpcSpec const kRPC_SPEC = { + static RpcSpec const kRpcSpec = { {JS(feature), validation::Type{}}, {JS(vetoed), meta::WithCustomError{ @@ -115,7 +115,7 @@ FeatureHandler::spec([[maybe_unused]] uint32_t apiVersion) {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } void diff --git a/src/rpc/handlers/GatewayBalances.hpp b/src/rpc/handlers/GatewayBalances.hpp index df5c1f668..0c8707891 100644 --- a/src/rpc/handlers/GatewayBalances.hpp +++ b/src/rpc/handlers/GatewayBalances.hpp @@ -128,20 +128,20 @@ public: }; }; - static auto const kSPEC_COMMON = RpcSpec{ + static auto const kSpecCommon = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator} }; - static auto const kSPEC_V1 = RpcSpec{ - kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_HOTWALLET)}} + static auto const kSpecV1 = RpcSpec{ + kSpecCommon, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_HOTWALLET)}} }; - static auto const kSPEC_V2 = RpcSpec{ - kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_PARAMS)}} + static auto const kSpecV2 = RpcSpec{ + kSpecCommon, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_PARAMS)}} }; - return apiVersion == 1 ? kSPEC_V1 : kSPEC_V2; + return apiVersion == 1 ? kSpecV1 : kSpecV2; } /** diff --git a/src/rpc/handlers/GetAggregatePrice.cpp b/src/rpc/handlers/GetAggregatePrice.cpp index 44cdc464f..2f2261856 100644 --- a/src/rpc/handlers/GetAggregatePrice.cpp +++ b/src/rpc/handlers/GetAggregatePrice.cpp @@ -178,11 +178,11 @@ GetAggregatePriceHandler::process( auto const median = [&, size = out.extireStats.size]() { auto const middle = size / 2; if ((size % 2) == 0) { - static ripple::STAmount const kTWO{ripple::noIssue(), 2, 0}; + static ripple::STAmount const kTwo{ripple::noIssue(), 2, 0}; auto it = itAdvance(timestampPricesBiMap.right.begin(), middle - 1); auto const& a1 = it->first; auto const& a2 = (++it)->first; - return divide(a1 + a2, kTWO, ripple::noIssue()); + return divide(a1 + a2, kTwo, ripple::noIssue()); } return itAdvance(timestampPricesBiMap.right.begin(), middle)->first; }(); @@ -198,7 +198,7 @@ GetAggregatePriceHandler::tracebackOracleObject( std::function const& callback ) const { - static constexpr auto kHISTORY_MAX = 3; + static constexpr auto kHistoryMax = 3; std::optional optOracleObject = oracleObject; std::optional optCurrentObject = optOracleObject; @@ -216,7 +216,7 @@ GetAggregatePriceHandler::tracebackOracleObject( if (callback(*optOracleObject) or isNew) return; - if (++history > kHISTORY_MAX) + if (++history > kHistoryMax) return; auto const prevTxIndex = optCurrentObject->getFieldH256(ripple::sfPreviousTxnID); diff --git a/src/rpc/handlers/GetAggregatePrice.hpp b/src/rpc/handlers/GetAggregatePrice.hpp index 2b4157c10..65cf676aa 100644 --- a/src/rpc/handlers/GetAggregatePrice.hpp +++ b/src/rpc/handlers/GetAggregatePrice.hpp @@ -100,12 +100,12 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static constexpr auto kORACLES_MAX = 200; + static constexpr auto kOraclesMax = 200; - static auto const kORACLES_VALIDATOR = modifiers::CustomModifier{ + static auto const kOraclesValidator = modifiers::CustomModifier{ [](boost::json::value& value, std::string_view) -> MaybeError { if (!value.is_array() or value.as_array().empty() or - value.as_array().size() > kORACLES_MAX) + value.as_array().size() > kOraclesMax) return Error{Status{RippledError::rpcORACLE_MALFORMED}}; for (auto& oracle : value.as_array()) { @@ -135,7 +135,7 @@ public: } }; - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, // validate quoteAsset and base_asset in accordance to the currency code found in XRPL @@ -155,7 +155,7 @@ public: validation::CustomValidators::currencyValidator, Status(RippledError::rpcINVALID_PARAMS) }}, - {JS(oracles), validation::Required{}, kORACLES_VALIDATOR}, + {JS(oracles), validation::Required{}, kOraclesValidator}, // note: Unlike `rippled`, Clio only supports UInt as input, no string, no `null`, etc. {JS(time_threshold), validation::Type{}}, { @@ -165,7 +165,7 @@ public: } }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/Ledger.hpp b/src/rpc/handlers/Ledger.hpp index ae446cd00..7a06ef626 100644 --- a/src/rpc/handlers/Ledger.hpp +++ b/src/rpc/handlers/Ledger.hpp @@ -93,7 +93,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(full), validation::Type{}, validation::NotSupported{true}}, {JS(full), check::Deprecated{}}, {JS(accounts), validation::Type{}, validation::NotSupported{true}}, @@ -110,7 +110,7 @@ public: {JS(type), check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/LedgerData.cpp b/src/rpc/handlers/LedgerData.cpp index 109a96633..6d4bee0b6 100644 --- a/src/rpc/handlers/LedgerData.cpp +++ b/src/rpc/handlers/LedgerData.cpp @@ -101,7 +101,7 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const // framework can not handler the check right now, adjust the value here auto const limit = std::min( input.limit, - input.binary ? LedgerDataHandler::kLIMIT_BINARY : LedgerDataHandler::kLIMIT_JSON + input.binary ? LedgerDataHandler::kLimitBinary : LedgerDataHandler::kLimitJson ); auto page = sharedPtrBackend_->fetchLedgerPage( input.marker, lgrInfo.seq, limit, input.outOfOrder, ctx.yield @@ -187,7 +187,7 @@ tag_invoke(boost::json::value_to_tag, boost::json::val if (jsonObject.contains(JS(binary))) { input.binary = jsonObject.at(JS(binary)).as_bool(); input.limit = - input.binary ? LedgerDataHandler::kLIMIT_BINARY : LedgerDataHandler::kLIMIT_JSON; + input.binary ? LedgerDataHandler::kLimitBinary : LedgerDataHandler::kLimitJson; } if (jsonObject.contains(JS(limit))) diff --git a/src/rpc/handlers/LedgerData.hpp b/src/rpc/handlers/LedgerData.hpp index d053f7e3d..80881fbca 100644 --- a/src/rpc/handlers/LedgerData.hpp +++ b/src/rpc/handlers/LedgerData.hpp @@ -37,8 +37,8 @@ class LedgerDataHandler { public: // constants - static constexpr uint32_t kLIMIT_BINARY = 2048; - static constexpr uint32_t kLIMIT_JSON = 256; + static constexpr uint32_t kLimitBinary = 2048; + static constexpr uint32_t kLimitJson = 256; /** * @brief A struct to hold the output data of the command @@ -64,7 +64,7 @@ public: std::optional ledgerHash; std::optional ledgerIndex; bool binary = false; - uint32_t limit = LedgerDataHandler::kLIMIT_JSON; // max 256 for json ; 2048 for binary + uint32_t limit = LedgerDataHandler::kLimitJson; // max 256 for json ; 2048 for binary std::optional marker; std::optional diffMarker; bool outOfOrder = false; @@ -92,7 +92,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(binary), validation::Type{}}, {"out_of_order", validation::Type{}}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, @@ -104,7 +104,7 @@ public: {JS(type), validation::CustomValidators::ledgerTypeValidator}, {JS(ledger), check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/LedgerEntry.cpp b/src/rpc/handlers/LedgerEntry.cpp index f07a85ad2..66ecde42e 100644 --- a/src/rpc/handlers/LedgerEntry.cpp +++ b/src/rpc/handlers/LedgerEntry.cpp @@ -368,36 +368,34 @@ tag_invoke(boost::json::value_to_tag, boost::json::va input.binary = jv.at(JS(binary)).as_bool(); // check all the potential index - static auto const kINDEX_FIELD_TYPE_MAP = - std::unordered_map{ - {JS(index), ripple::ltANY}, - {JS(directory), ripple::ltDIR_NODE}, - {JS(offer), ripple::ltOFFER}, - {JS(check), ripple::ltCHECK}, - {JS(escrow), ripple::ltESCROW}, - {JS(payment_channel), ripple::ltPAYCHAN}, - {JS(deposit_preauth), ripple::ltDEPOSIT_PREAUTH}, - {JS(ticket), ripple::ltTICKET}, - {JS(nft_page), ripple::ltNFTOKEN_PAGE}, - {JS(amm), ripple::ltAMM}, - {JS(xchain_owned_create_account_claim_id), - ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, - {JS(xchain_owned_claim_id), ripple::ltXCHAIN_OWNED_CLAIM_ID}, - {JS(oracle), ripple::ltORACLE}, - {JS(credential), ripple::ltCREDENTIAL}, - {JS(mptoken), ripple::ltMPTOKEN}, - {JS(permissioned_domain), ripple::ltPERMISSIONED_DOMAIN}, - {JS(vault), ripple::ltVAULT}, - {JS(loan_broker), ripple::ltLOAN_BROKER}, - {JS(loan), ripple::ltLOAN}, - {JS(delegate), ripple::ltDELEGATE}, - {JS(amendments), ripple::ltAMENDMENTS}, - {JS(fee), ripple::ltFEE_SETTINGS}, - {JS(hashes), ripple::ltLEDGER_HASHES}, - {JS(nft_offer), ripple::ltNFTOKEN_OFFER}, - {JS(nunl), ripple::ltNEGATIVE_UNL}, - {JS(signer_list), ripple::ltSIGNER_LIST}, - }; + static auto const kIndexFieldTypeMap = std::unordered_map{ + {JS(index), ripple::ltANY}, + {JS(directory), ripple::ltDIR_NODE}, + {JS(offer), ripple::ltOFFER}, + {JS(check), ripple::ltCHECK}, + {JS(escrow), ripple::ltESCROW}, + {JS(payment_channel), ripple::ltPAYCHAN}, + {JS(deposit_preauth), ripple::ltDEPOSIT_PREAUTH}, + {JS(ticket), ripple::ltTICKET}, + {JS(nft_page), ripple::ltNFTOKEN_PAGE}, + {JS(amm), ripple::ltAMM}, + {JS(xchain_owned_create_account_claim_id), ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, + {JS(xchain_owned_claim_id), ripple::ltXCHAIN_OWNED_CLAIM_ID}, + {JS(oracle), ripple::ltORACLE}, + {JS(credential), ripple::ltCREDENTIAL}, + {JS(mptoken), ripple::ltMPTOKEN}, + {JS(permissioned_domain), ripple::ltPERMISSIONED_DOMAIN}, + {JS(vault), ripple::ltVAULT}, + {JS(loan_broker), ripple::ltLOAN_BROKER}, + {JS(loan), ripple::ltLOAN}, + {JS(delegate), ripple::ltDELEGATE}, + {JS(amendments), ripple::ltAMENDMENTS}, + {JS(fee), ripple::ltFEE_SETTINGS}, + {JS(hashes), ripple::ltLEDGER_HASHES}, + {JS(nft_offer), ripple::ltNFTOKEN_OFFER}, + {JS(nunl), ripple::ltNEGATIVE_UNL}, + {JS(signer_list), ripple::ltSIGNER_LIST}, + }; auto const parseBridgeFromJson = [](boost::json::value const& bridgeJson) { auto const lockingDoor = @@ -444,12 +442,12 @@ tag_invoke(boost::json::value_to_tag, boost::json::va }; auto const indexFieldType = - std::ranges::find_if(kINDEX_FIELD_TYPE_MAP, [&jsonObject](auto const& pair) { + std::ranges::find_if(kIndexFieldTypeMap, [&jsonObject](auto const& pair) { auto const& [field, _] = pair; return jsonObject.contains(field) && jsonObject.at(field).is_string(); }); - if (indexFieldType != kINDEX_FIELD_TYPE_MAP.end()) { + if (indexFieldType != kIndexFieldTypeMap.end()) { input.index = boost::json::value_to(jv.at(indexFieldType->first)); input.expectedType = indexFieldType->second; } diff --git a/src/rpc/handlers/LedgerEntry.hpp b/src/rpc/handlers/LedgerEntry.hpp index 293926468..b6e4df945 100644 --- a/src/rpc/handlers/LedgerEntry.hpp +++ b/src/rpc/handlers/LedgerEntry.hpp @@ -123,7 +123,7 @@ public: // Validator only works in this handler // The accounts array must have two different elements // Each element must be a valid address - static auto const kRIPPLE_STATE_ACCOUNTS_CHECK = validation::CustomValidator{ + static auto const kRippleStateAccountsCheck = validation::CustomValidator{ [](boost::json::value const& value, std::string_view /* key */) -> MaybeError { if (!value.is_array() || value.as_array().size() != 2 || !value.as_array()[0].is_string() || !value.as_array()[1].is_string() || @@ -145,16 +145,16 @@ public: } }; - static auto const kMALFORMED_REQUEST_HEX_STRING_VALIDATOR = meta::WithCustomError{ + static auto const kMalformedRequestHexStringValidator = meta::WithCustomError{ validation::CustomValidators::uint256HexStringValidator, Status(ClioError::RpcMalformedRequest) }; - static auto const kMALFORMED_REQUEST_INT_VALIDATOR = meta::WithCustomError{ + static auto const kMalformedRequestIntValidator = meta::WithCustomError{ validation::Type{}, Status(ClioError::RpcMalformedRequest) }; - static auto const kBRIDGE_JSON_VALIDATOR = meta::WithCustomError{ + static auto const kBridgeJsonValidator = meta::WithCustomError{ meta::IfType{meta::Section{ {ripple::sfLockingChainDoor.getJsonName().c_str(), validation::Required{}, @@ -172,17 +172,17 @@ public: Status(ClioError::RpcMalformedRequest) }; - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(binary), validation::Type{}}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, - {JS(index), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + {JS(index), kMalformedRequestHexStringValidator}, {JS(account_root), validation::CustomValidators::accountBase58Validator}, {JS(did), validation::CustomValidators::accountBase58Validator}, - {JS(check), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + {JS(check), kMalformedRequestHexStringValidator}, {JS(deposit_preauth), validation::Type{}, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{ meta::Section{ {JS(owner), @@ -198,15 +198,15 @@ public: }}, {JS(directory), validation::Type{}, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{meta::Section{ {JS(owner), validation::CustomValidators::accountBase58Validator}, {JS(dir_root), validation::CustomValidators::uint256HexStringValidator}, - {JS(sub_index), kMALFORMED_REQUEST_INT_VALIDATOR} + {JS(sub_index), kMalformedRequestIntValidator} }}}, {JS(escrow), validation::Type{}, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{ meta::Section{ {JS(owner), @@ -215,44 +215,44 @@ public: validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedOwner) }}, - {JS(seq), validation::Required{}, kMALFORMED_REQUEST_INT_VALIDATOR}, + {JS(seq), validation::Required{}, kMalformedRequestIntValidator}, }, }}, {JS(offer), validation::Type{}, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{ meta::Section{ {JS(account), validation::Required{}, validation::CustomValidators::accountBase58Validator}, - {JS(seq), validation::Required{}, kMALFORMED_REQUEST_INT_VALIDATOR}, + {JS(seq), validation::Required{}, kMalformedRequestIntValidator}, }, }}, - {JS(payment_channel), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + {JS(payment_channel), kMalformedRequestHexStringValidator}, {JS(ripple_state), validation::Type{}, meta::Section{ - {JS(accounts), validation::Required{}, kRIPPLE_STATE_ACCOUNTS_CHECK}, + {JS(accounts), validation::Required{}, kRippleStateAccountsCheck}, {JS(currency), validation::Required{}, validation::CustomValidators::currencyValidator}, }}, {JS(ticket), validation::Type{}, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{ meta::Section{ {JS(account), validation::Required{}, validation::CustomValidators::accountBase58Validator}, - {JS(ticket_seq), validation::Required{}, kMALFORMED_REQUEST_INT_VALIDATOR}, + {JS(ticket_seq), validation::Required{}, kMalformedRequestIntValidator}, }, }}, - {JS(nft_page), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + {JS(nft_page), kMalformedRequestHexStringValidator}, {JS(amm), validation::Type{}, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{ meta::Section{ {JS(asset), @@ -279,7 +279,7 @@ public: meta::WithCustomError{ validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - kBRIDGE_JSON_VALIDATOR}, + kBridgeJsonValidator}, {JS(bridge_account), meta::WithCustomError{ validation::CustomValidators::accountBase58Validator, @@ -290,8 +290,8 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - kBRIDGE_JSON_VALIDATOR, + meta::IfType{kMalformedRequestHexStringValidator}, + kBridgeJsonValidator, meta::WithCustomError{ meta::IfType{meta::Section{ {JS(xchain_owned_claim_id), @@ -305,8 +305,8 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - kBRIDGE_JSON_VALIDATOR, + meta::IfType{kMalformedRequestHexStringValidator}, + kBridgeJsonValidator, meta::WithCustomError{ meta::IfType{meta::Section{ {JS(xchain_owned_create_account_claim_id), @@ -321,7 +321,7 @@ public: Status(ClioError::RpcMalformedRequest) }, meta::IfType{meta::WithCustomError{ - kMALFORMED_REQUEST_HEX_STRING_VALIDATOR, Status(ClioError::RpcMalformedAddress) + kMalformedRequestHexStringValidator, Status(ClioError::RpcMalformedAddress) }}, meta::IfType{meta::Section{ {JS(account), @@ -352,7 +352,7 @@ public: Status(ClioError::RpcMalformedRequest) }, meta::IfType{meta::WithCustomError{ - kMALFORMED_REQUEST_HEX_STRING_VALIDATOR, Status(ClioError::RpcMalformedAddress) + kMalformedRequestHexStringValidator, Status(ClioError::RpcMalformedAddress) }}, meta::IfType{meta::Section{ {JS(subject), @@ -391,7 +391,7 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{ meta::Section{ { @@ -421,7 +421,7 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{meta::Section{ {JS(seq), meta::WithCustomError{ @@ -446,7 +446,7 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{meta::Section{ {JS(seq), meta::WithCustomError{ @@ -471,7 +471,7 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{meta::Section{ {JS(seq), meta::WithCustomError{ @@ -496,7 +496,7 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{meta::Section{ {JS(loan_seq), meta::WithCustomError{ @@ -521,7 +521,7 @@ public: validation::Type{}, Status(ClioError::RpcMalformedRequest) }, - meta::IfType{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + meta::IfType{kMalformedRequestHexStringValidator}, meta::IfType{meta::Section{ {JS(account), meta::WithCustomError{ @@ -540,17 +540,17 @@ public: Status(ClioError::RpcMalformedAddress) }} }}}, - {JS(amendments), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - {JS(fee), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - {JS(hashes), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - {JS(nft_offer), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - {JS(nunl), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, - {JS(signer_list), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR}, + {JS(amendments), kMalformedRequestHexStringValidator}, + {JS(fee), kMalformedRequestHexStringValidator}, + {JS(hashes), kMalformedRequestHexStringValidator}, + {JS(nft_offer), kMalformedRequestHexStringValidator}, + {JS(nunl), kMalformedRequestHexStringValidator}, + {JS(signer_list), kMalformedRequestHexStringValidator}, {JS(ledger), check::Deprecated{}}, {"include_deleted", validation::Type{}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/LedgerIndex.cpp b/src/rpc/handlers/LedgerIndex.cpp index 293de1ae4..794395b27 100644 --- a/src/rpc/handlers/LedgerIndex.cpp +++ b/src/rpc/handlers/LedgerIndex.cpp @@ -42,7 +42,7 @@ LedgerIndexHandler::process(LedgerIndexHandler::Input const& input, Context cons return fillOutputByIndex(maxIndex); auto const convertISOTimeStrToTicks = [](std::string const& isoTimeStr) { - auto const systemTime = util::systemTpFromUtcStr(isoTimeStr, kDATE_FORMAT); + auto const systemTime = util::systemTpFromUtcStr(isoTimeStr, kDateFormat); // systemTime must be valid after validation passed return systemTime->time_since_epoch().count(); }; diff --git a/src/rpc/handlers/LedgerIndex.hpp b/src/rpc/handlers/LedgerIndex.hpp index c79a34c29..65c709c55 100644 --- a/src/rpc/handlers/LedgerIndex.hpp +++ b/src/rpc/handlers/LedgerIndex.hpp @@ -22,7 +22,7 @@ namespace rpc { */ class LedgerIndexHandler { std::shared_ptr sharedPtrBackend_; - static constexpr auto kDATE_FORMAT = "%Y-%m-%dT%TZ"; + static constexpr auto kDateFormat = "%Y-%m-%dT%TZ"; public: /** @@ -62,12 +62,12 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(date), validation::Type{}, - validation::TimeFormatValidator{kDATE_FORMAT}}, + validation::TimeFormatValidator{kDateFormat}}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/MPTHolders.cpp b/src/rpc/handlers/MPTHolders.cpp index 2fdbebd73..57a61f837 100644 --- a/src/rpc/handlers/MPTHolders.cpp +++ b/src/rpc/handlers/MPTHolders.cpp @@ -45,7 +45,7 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input const& input, Context const& return Error{expectedLgrInfo.error()}; auto const& lgrInfo = *expectedLgrInfo; - auto const limit = input.limit.value_or(MPTHoldersHandler::kLIMIT_DEFAULT); + auto const limit = input.limit.value_or(MPTHoldersHandler::kLimitDefault); auto const mptID = ripple::uint192{input.mptID.c_str()}; auto const issuanceLedgerObject = sharedPtrBackend_->fetchLedgerObject( diff --git a/src/rpc/handlers/MPTHolders.hpp b/src/rpc/handlers/MPTHolders.hpp index 22c302f84..daed106ed 100644 --- a/src/rpc/handlers/MPTHolders.hpp +++ b/src/rpc/handlers/MPTHolders.hpp @@ -27,9 +27,9 @@ class MPTHoldersHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 1; - static constexpr auto kLIMIT_MAX = 100; - static constexpr auto kLIMIT_DEFAULT = 50; + static constexpr auto kLimitMin = 1; + static constexpr auto kLimitMax = 100; + static constexpr auto kLimitDefault = 50; /** * @brief A struct to hold the output data of the command @@ -75,7 +75,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(mpt_issuance_id), validation::Required{}, validation::CustomValidators::uint192HexStringValidator}, @@ -84,11 +84,11 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(marker), validation::CustomValidators::uint160HexStringValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/NFTHistory.cpp b/src/rpc/handlers/NFTHistory.cpp index 8699f99aa..86dc883cd 100644 --- a/src/rpc/handlers/NFTHistory.cpp +++ b/src/rpc/handlers/NFTHistory.cpp @@ -95,7 +95,7 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& } } - auto const limit = input.limit.value_or(kLIMIT_DEFAULT); + auto const limit = input.limit.value_or(kLimitDefault); auto const tokenID = ripple::uint256{input.nftID.c_str()}; auto const [txnsAndCursor, timeDiff] = util::timed([&]() { diff --git a/src/rpc/handlers/NFTHistory.hpp b/src/rpc/handlers/NFTHistory.hpp index 8cc982cc3..2fca709ef 100644 --- a/src/rpc/handlers/NFTHistory.hpp +++ b/src/rpc/handlers/NFTHistory.hpp @@ -35,9 +35,9 @@ class NFTHistoryHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 1; - static constexpr auto kLIMIT_MAX = 100; - static constexpr auto kLIMIT_DEFAULT = 50; + static constexpr auto kLimitMin = 1; + static constexpr auto kLimitMax = 100; + static constexpr auto kLimitDefault = 50; /** * @brief A struct to hold the marker data @@ -101,7 +101,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(nft_id), validation::Required{}, validation::CustomValidators::uint256HexStringValidator}, @@ -114,7 +114,7 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(marker), meta::WithCustomError{ validation::Type{}, @@ -126,7 +126,7 @@ public: }}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/NFTInfo.hpp b/src/rpc/handlers/NFTInfo.hpp index 2fb1a8e96..56ddd95bf 100644 --- a/src/rpc/handlers/NFTInfo.hpp +++ b/src/rpc/handlers/NFTInfo.hpp @@ -76,7 +76,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(nft_id), validation::Required{}, validation::CustomValidators::uint256HexStringValidator}, @@ -84,7 +84,7 @@ public: {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/NFTOffersCommon.hpp b/src/rpc/handlers/NFTOffersCommon.hpp index 39ca80f16..993195737 100644 --- a/src/rpc/handlers/NFTOffersCommon.hpp +++ b/src/rpc/handlers/NFTOffersCommon.hpp @@ -30,9 +30,9 @@ class NFTOffersHandlerBase { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 50; - static constexpr auto kLIMIT_MAX = 500; - static constexpr auto kLIMIT_DEFAULT = 250; + static constexpr auto kLimitMin = 50; + static constexpr auto kLimitMax = 500; + static constexpr auto kLimitDefault = 250; /** * @brief A struct to hold the output data of the command @@ -54,7 +54,7 @@ public: std::string nftID; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; std::optional marker; }; @@ -79,7 +79,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(nft_id), validation::Required{}, validation::CustomValidators::uint256HexStringValidator}, @@ -88,11 +88,11 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(marker), validation::CustomValidators::uint256HexStringValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } protected: diff --git a/src/rpc/handlers/NFTsByIssuer.cpp b/src/rpc/handlers/NFTsByIssuer.cpp index fcd624c77..f797ba7bf 100644 --- a/src/rpc/handlers/NFTsByIssuer.cpp +++ b/src/rpc/handlers/NFTsByIssuer.cpp @@ -45,7 +45,7 @@ NFTsByIssuerHandler::process(NFTsByIssuerHandler::Input const& input, Context co auto const& lgrInfo = *expectedLgrInfo; - auto const limit = input.limit.value_or(NFTsByIssuerHandler::kLIMIT_DEFAULT); + auto const limit = input.limit.value_or(NFTsByIssuerHandler::kLimitDefault); auto const issuer = accountFromStringStrict(input.issuer); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( diff --git a/src/rpc/handlers/NFTsByIssuer.hpp b/src/rpc/handlers/NFTsByIssuer.hpp index 6765fd180..6e79a6a3a 100644 --- a/src/rpc/handlers/NFTsByIssuer.hpp +++ b/src/rpc/handlers/NFTsByIssuer.hpp @@ -26,9 +26,9 @@ class NFTsByIssuerHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 1; - static constexpr auto kLIMIT_MAX = 100; - static constexpr auto kLIMIT_DEFAULT = 50; + static constexpr auto kLimitMin = 1; + static constexpr auto kLimitMax = 100; + static constexpr auto kLimitDefault = 50; /** * @brief A struct to hold the output data of the command @@ -76,7 +76,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(issuer), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(nft_taxon), validation::Type{}}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, @@ -84,11 +84,11 @@ public: {JS(limit), validation::Type{}, validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, + modifiers::Clamp{kLimitMin, kLimitMax}}, {JS(marker), validation::CustomValidators::uint256HexStringValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/NoRippleCheck.hpp b/src/rpc/handlers/NoRippleCheck.hpp index a8db6a64e..5d2af934d 100644 --- a/src/rpc/handlers/NoRippleCheck.hpp +++ b/src/rpc/handlers/NoRippleCheck.hpp @@ -36,9 +36,9 @@ class NoRippleCheckHandler { std::shared_ptr sharedPtrBackend_; public: - static constexpr auto kLIMIT_MIN = 1; - static constexpr auto kLIMIT_MAX = 500; - static constexpr auto kLIMIT_DEFAULT = 300; + static constexpr auto kLimitMin = 1; + static constexpr auto kLimitMax = 500; + static constexpr auto kLimitDefault = 300; /** * @brief A struct to hold the output data of the command @@ -60,7 +60,7 @@ public: bool roleGateway = false; std::optional ledgerHash; std::optional ledgerIndex; - uint32_t limit = kLIMIT_DEFAULT; + uint32_t limit = kLimitDefault; JsonBool transactions{false}; }; @@ -85,7 +85,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC_V1 = RpcSpec{ + static auto const kRpcSpecV1 = RpcSpec{ {JS(account), validation::Required{}, validation::CustomValidators::accountValidator}, {JS(role), validation::Required{}, @@ -98,17 +98,17 @@ public: {JS(limit), validation::Type(), validation::Min(1u), - modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}} + modifiers::Clamp{kLimitMin, kLimitMax}} }; - static auto const kRPC_SPEC = RpcSpec{ - kRPC_SPEC_V1, + static auto const kRpcSpec = RpcSpec{ + kRpcSpecV1, { {JS(transactions), validation::Type()}, } }; - return apiVersion == 1 ? kRPC_SPEC_V1 : kRPC_SPEC; + return apiVersion == 1 ? kRpcSpecV1 : kRpcSpec; } /** diff --git a/src/rpc/handlers/ServerInfo.hpp b/src/rpc/handlers/ServerInfo.hpp index 95ce881fc..8262d89d9 100644 --- a/src/rpc/handlers/ServerInfo.hpp +++ b/src/rpc/handlers/ServerInfo.hpp @@ -45,7 +45,7 @@ namespace rpc { */ template class BaseServerInfoHandler { - static constexpr auto kBACKEND_COUNTERS_KEY = "backend_counters"; + static constexpr auto kBackendCountersKey = "backend_counters"; std::shared_ptr backend_; std::shared_ptr subscriptions_; @@ -156,8 +156,8 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static RpcSpec const kRPC_SPEC = {}; - return kRPC_SPEC; + static RpcSpec const kRpcSpec = {}; + return kRpcSpec; } /** @@ -193,7 +193,7 @@ public: duration_cast(system_clock::now().time_since_epoch()).count(); auto const age = static_cast(sinceEpoch) - static_cast(lgrInfo->closeTime.time_since_epoch().count()) - - static_cast(kRIPPLE_EPOCH_START); + static_cast(kRippleEpochStart); // NOLINTBEGIN(bugprone-unchecked-optional-access) output.info.completeLedgers = fmt::format("{}-{}", range->minSequence, range->maxSequence); @@ -292,7 +292,7 @@ private: jv.as_object()[JS(counters)].as_object()["subscriptions"] = info.adminSection->subscriptions; if (info.adminSection->backendCounters.has_value()) { - jv.as_object()[kBACKEND_COUNTERS_KEY] = *info.adminSection->backendCounters; + jv.as_object()[kBackendCountersKey] = *info.adminSection->backendCounters; } } } @@ -334,9 +334,9 @@ private: { auto input = BaseServerInfoHandler::Input{}; auto const jsonObject = jv.as_object(); - if (jsonObject.contains(kBACKEND_COUNTERS_KEY) && - jsonObject.at(kBACKEND_COUNTERS_KEY).is_bool()) - input.backendCounters = jv.at(kBACKEND_COUNTERS_KEY).as_bool(); + if (jsonObject.contains(kBackendCountersKey) && + jsonObject.at(kBackendCountersKey).is_bool()) + input.backendCounters = jv.at(kBackendCountersKey).as_bool(); return input; } }; diff --git a/src/rpc/handlers/Subscribe.cpp b/src/rpc/handlers/Subscribe.cpp index 8e038e241..534ba274b 100644 --- a/src/rpc/handlers/Subscribe.cpp +++ b/src/rpc/handlers/Subscribe.cpp @@ -49,7 +49,7 @@ SubscribeHandler::SubscribeHandler( RpcSpecConstRef SubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kBOOKS_VALIDATOR = validation::CustomValidator{ + static auto const kBooksValidator = validation::CustomValidator{ [](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_array()) { return Error{ @@ -91,17 +91,17 @@ SubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) } }; - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(streams), validation::CustomValidators::subscribeStreamValidator}, {JS(accounts), validation::CustomValidators::subscribeAccountsValidator}, {JS(accounts_proposed), validation::CustomValidators::subscribeAccountsValidator}, - {JS(books), kBOOKS_VALIDATOR}, + {JS(books), kBooksValidator}, {"user", check::Deprecated{}}, {JS(password), check::Deprecated{}}, {JS(rt_accounts), check::Deprecated{}} }; - return kRPC_SPEC; + return kRpcSpec; } SubscribeHandler::Result @@ -192,7 +192,7 @@ SubscribeHandler::subscribeToBooks( Output& output ) const { - static constexpr auto kFETCH_LIMIT = 200; + static constexpr auto kFetchLimit = 200; std::optional rng; @@ -206,7 +206,7 @@ SubscribeHandler::subscribeToBooks( auto const getOrderBook = [&](auto const& book, auto& snapshots) { auto const bookBase = getBookBase(book); auto const [offers, _] = sharedPtrBackend_->fetchBookOffers( - bookBase, rng->maxSequence, kFETCH_LIMIT, yield + bookBase, rng->maxSequence, kFetchLimit, yield ); // the taker is not really used, same issue with diff --git a/src/rpc/handlers/TransactionEntry.hpp b/src/rpc/handlers/TransactionEntry.hpp index 919893b4e..98fd1e9d7 100644 --- a/src/rpc/handlers/TransactionEntry.hpp +++ b/src/rpc/handlers/TransactionEntry.hpp @@ -74,7 +74,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(tx_hash), meta::WithCustomError{ validation::Required{}, Status(ClioError::RpcFieldNotFoundTransaction) @@ -84,7 +84,7 @@ public: {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/rpc/handlers/Tx.hpp b/src/rpc/handlers/Tx.hpp index 7ae874aca..3bedf60f9 100644 --- a/src/rpc/handlers/Tx.hpp +++ b/src/rpc/handlers/Tx.hpp @@ -104,17 +104,17 @@ public: static RpcSpecConstRef spec(uint32_t apiVersion) { - static RpcSpec const kRPC_SPEC_FOR_V1 = { + static RpcSpec const kRpcSpecForV1 = { {JS(transaction), validation::CustomValidators::uint256HexStringValidator}, {JS(min_ledger), validation::Type{}}, {JS(max_ledger), validation::Type{}}, {JS(ctid), validation::Type{}}, }; - static auto const kRPC_SPEC = - RpcSpec{kRPC_SPEC_FOR_V1, {{JS(binary), validation::Type{}}}}; + static auto const kRpcSpec = + RpcSpec{kRpcSpecForV1, {{JS(binary), validation::Type{}}}}; - return apiVersion == 1 ? kRPC_SPEC_FOR_V1 : kRPC_SPEC; + return apiVersion == 1 ? kRpcSpecForV1 : kRpcSpec; } /** @@ -133,14 +133,14 @@ public: if (!input.ctid && !input.transaction) // at least one identifier must be supplied return Error{Status{RippledError::rpcINVALID_PARAMS}}; - static constexpr auto kMAX_LEDGER_RANGE = 1000u; + static constexpr auto kMaxLedgerRange = 1000u; auto const rangeSupplied = input.minLedger && input.maxLedger; if (rangeSupplied) { if (*input.minLedger > *input.maxLedger) return Error{Status{RippledError::rpcINVALID_LGR_RANGE}}; - if (*input.maxLedger - *input.minLedger > kMAX_LEDGER_RANGE) + if (*input.maxLedger - *input.minLedger > kMaxLedgerRange) return Error{Status{RippledError::rpcEXCESSIVE_LGR_RANGE}}; } diff --git a/src/rpc/handlers/Unsubscribe.cpp b/src/rpc/handlers/Unsubscribe.cpp index 41a5b8ea0..ba58983c8 100644 --- a/src/rpc/handlers/Unsubscribe.cpp +++ b/src/rpc/handlers/Unsubscribe.cpp @@ -35,7 +35,7 @@ UnsubscribeHandler::UnsubscribeHandler( RpcSpecConstRef UnsubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kBOOKS_VALIDATOR = validation::CustomValidator{ + static auto const kBooksValidator = validation::CustomValidator{ [](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_array()) { return Error{ @@ -62,17 +62,17 @@ UnsubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) } }; - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(streams), validation::CustomValidators::subscribeStreamValidator}, {JS(accounts), validation::CustomValidators::subscribeAccountsValidator}, {JS(accounts_proposed), validation::CustomValidators::subscribeAccountsValidator}, - {JS(books), kBOOKS_VALIDATOR}, + {JS(books), kBooksValidator}, {JS(url), check::Deprecated{}}, {JS(rt_accounts), check::Deprecated{}}, {"rt_transactions", check::Deprecated{}}, }; - return kRPC_SPEC; + return kRpcSpec; } UnsubscribeHandler::Result diff --git a/src/rpc/handlers/VaultInfo.hpp b/src/rpc/handlers/VaultInfo.hpp index aae4af92c..c2a04818c 100644 --- a/src/rpc/handlers/VaultInfo.hpp +++ b/src/rpc/handlers/VaultInfo.hpp @@ -65,7 +65,7 @@ public: static RpcSpecConstRef spec([[maybe_unused]] uint32_t apiVersion) { - static auto const kRPC_SPEC = RpcSpec{ + static auto const kRpcSpec = RpcSpec{ {JS(vault_id), meta::WithCustomError{ validation::CustomValidators::uint256HexStringValidator, @@ -83,7 +83,7 @@ public: {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, }; - return kRPC_SPEC; + return kRpcSpec; } /** diff --git a/src/util/Channel.hpp b/src/util/Channel.hpp index deeeee5c7..753c88cce 100644 --- a/src/util/Channel.hpp +++ b/src/util/Channel.hpp @@ -59,8 +59,8 @@ enum class ConsumerType { */ template class Channel { - static constexpr bool kIS_MULTI_PRODUCER = (P == ProducerType::Multi); - static constexpr bool kIS_MULTI_CONSUMER = (C == ConsumerType::Multi); + static constexpr bool kIsMultiProducer = (P == ProducerType::Multi); + static constexpr bool kIsMultiConsumer = (C == ConsumerType::Multi); private: class ControlBlock { @@ -134,7 +134,7 @@ public: */ class Sender { std::shared_ptr shared_; - std::conditional_t, Guard> guard_; + std::conditional_t, Guard> guard_; friend class Channel; @@ -144,7 +144,7 @@ public: */ Sender(std::shared_ptr shared) : shared_(shared), guard_([shared = std::move(shared)]() { - if constexpr (kIS_MULTI_PRODUCER) { + if constexpr (kIsMultiProducer) { return std::make_shared(std::move(shared)); } else { return Guard{std::move(shared)}; @@ -156,21 +156,21 @@ public: public: Sender(Sender&&) = default; Sender(Sender const&) - requires kIS_MULTI_PRODUCER + requires kIsMultiProducer = default; Sender(Sender const&) - requires(!kIS_MULTI_PRODUCER) + requires(!kIsMultiProducer) = delete; Sender& operator=(Sender&&) = default; Sender& operator=(Sender const&) - requires kIS_MULTI_PRODUCER + requires kIsMultiProducer = default; Sender& operator=(Sender const&) - requires(!kIS_MULTI_PRODUCER) + requires(!kIsMultiProducer) = delete; /** @@ -259,7 +259,7 @@ public: */ class Receiver { std::shared_ptr shared_; - std::conditional_t, Guard> guard_; + std::conditional_t, Guard> guard_; friend class Channel; @@ -269,7 +269,7 @@ public: */ Receiver(std::shared_ptr shared) : shared_(shared), guard_([shared = std::move(shared)]() { - if constexpr (kIS_MULTI_CONSUMER) { + if constexpr (kIsMultiConsumer) { return std::make_shared(std::move(shared)); } else { return Guard{std::move(shared)}; @@ -281,21 +281,21 @@ public: public: Receiver(Receiver&&) = default; Receiver(Receiver const&) - requires kIS_MULTI_CONSUMER + requires kIsMultiConsumer = default; Receiver(Receiver const&) - requires(!kIS_MULTI_CONSUMER) + requires(!kIsMultiConsumer) = delete; Receiver& operator=(Receiver&&) = default; Receiver& operator=(Receiver const&) - requires kIS_MULTI_CONSUMER + requires kIsMultiConsumer = default; Receiver& operator=(Receiver const&) - requires(!kIS_MULTI_CONSUMER) + requires(!kIsMultiConsumer) = delete; /** diff --git a/src/util/Concepts.hpp b/src/util/Concepts.hpp index 6461ba74d..8db6b99cf 100644 --- a/src/util/Concepts.hpp +++ b/src/util/Concepts.hpp @@ -39,9 +39,9 @@ template constexpr bool hasNoDuplicateNames() { - constexpr std::array kNAMES = {Types::kNAME...}; - return !std::ranges::any_of(kNAMES, [&](std::string_view const& name1) { - return std::ranges::any_of(kNAMES, [&](std::string_view const& name2) { + constexpr std::array kNames = {Types::kName...}; + return !std::ranges::any_of(kNames, [&](std::string_view const& name1) { + return std::ranges::any_of(kNames, [&](std::string_view const& name2) { return &name1 != &name2 && name1 == name2; // Ensure different elements are compared }); }); diff --git a/src/util/Constants.hpp b/src/util/Constants.hpp index 5bc749436..330820b9a 100644 --- a/src/util/Constants.hpp +++ b/src/util/Constants.hpp @@ -3,6 +3,6 @@ #include namespace util { -static constexpr std::size_t kMILLISECONDS_PER_SECOND = 1000; -static constexpr double kNANO_PER_SECOND = 1.0e9; +static constexpr std::size_t kMillisecondsPerSecond = 1000; +static constexpr double kNanoPerSecond = 1.0e9; } // namespace util diff --git a/src/util/LedgerUtils.cpp b/src/util/LedgerUtils.cpp index 8ce8b9623..3f3058c90 100644 --- a/src/util/LedgerUtils.cpp +++ b/src/util/LedgerUtils.cpp @@ -37,10 +37,10 @@ LedgerTypes::getLedgerTypeAttributeFromStr(std::string const& entryName) { static std::unordered_map< std::string, - std::reference_wrapper> const kNAME_MAP = []() { + std::reference_wrapper> const kNameMap = []() { std::unordered_map> map; - std::ranges::for_each(kLEDGER_TYPES, [&map](auto const& item) { + std::ranges::for_each(kLedgerTypes, [&map](auto const& item) { map.insert({util::toLower(item.name_), item}); }); return map; @@ -48,21 +48,21 @@ LedgerTypes::getLedgerTypeAttributeFromStr(std::string const& entryName) static std::unordered_map< std::string, - std::reference_wrapper> const kRPC_NAME_MAP = []() { + std::reference_wrapper> const kRpcNameMap = []() { std::unordered_map> map; - std::ranges::for_each(kLEDGER_TYPES, [&map](auto const& item) { + std::ranges::for_each(kLedgerTypes, [&map](auto const& item) { map.insert({item.rpcName_, item}); }); return map; }(); - if (auto const it = kRPC_NAME_MAP.find(entryName); it != kRPC_NAME_MAP.end()) { + if (auto const it = kRpcNameMap.find(entryName); it != kRpcNameMap.end()) { return it->second; } auto const entryNameLowercase = util::toLower(entryName); - if (auto const it = kNAME_MAP.find(entryNameLowercase); it != kNAME_MAP.end()) { + if (auto const it = kNameMap.find(entryNameLowercase); it != kNameMap.end()) { return it->second; } diff --git a/src/util/LedgerUtils.hpp b/src/util/LedgerUtils.hpp index 4a0c7f016..ae9ec7e01 100644 --- a/src/util/LedgerUtils.hpp +++ b/src/util/LedgerUtils.hpp @@ -78,7 +78,7 @@ class LedgerTypes { using LedgerTypeAttribute = impl::LedgerTypeAttribute; using LedgerTypeAttributeList = LedgerTypeAttribute[]; - static constexpr LedgerTypeAttributeList const kLEDGER_TYPES{ + static constexpr LedgerTypeAttributeList const kLedgerTypes{ LedgerTypeAttribute::accountOwnedLedgerType( JS(AccountRoot), JS(account), @@ -166,8 +166,8 @@ public: static constexpr auto getLedgerEntryTypeStrList() { - std::array res{}; - std::ranges::transform(kLEDGER_TYPES, std::begin(res), [](auto const& item) { + std::array res{}; + std::ranges::transform(kLedgerTypes, std::begin(res), [](auto const& item) { return item.rpcName_; }); return res; @@ -181,16 +181,16 @@ public: static constexpr auto getDeletionBlockerLedgerTypes() { - constexpr auto kFILTER = [](auto const& item) { + constexpr auto kFilter = [](auto const& item) { return item.category_ == LedgerTypeAttribute::LedgerCategory::DeletionBlocker; }; - constexpr auto kDELETION_BLOCKERS_COUNT = - std::count_if(std::begin(kLEDGER_TYPES), std::end(kLEDGER_TYPES), kFILTER); - std::array res{}; + constexpr auto kDeletionBlockersCount = + std::count_if(std::begin(kLedgerTypes), std::end(kLedgerTypes), kFilter); + std::array res{}; auto it = std::begin(res); - std::ranges::for_each(kLEDGER_TYPES, [&](auto const& item) { - if (kFILTER(item)) { + std::ranges::for_each(kLedgerTypes, [&](auto const& item) { + if (kFilter(item)) { *it = item.type_; ++it; } diff --git a/src/util/SignalsHandler.cpp b/src/util/SignalsHandler.cpp index b57d1f9ab..27631f3a7 100644 --- a/src/util/SignalsHandler.cpp +++ b/src/util/SignalsHandler.cpp @@ -87,7 +87,7 @@ SignalsHandler::notifyGracefulShutdownComplete() void SignalsHandler::setHandler(void (*handler)(int)) { - for (int const signal : kHANDLED_SIGNALS) + for (int const signal : kHandledSignals) std::signal(signal, handler == nullptr ? SIG_DFL : handler); } diff --git a/src/util/SignalsHandler.hpp b/src/util/SignalsHandler.hpp index 55acd7f0e..83137b3ac 100644 --- a/src/util/SignalsHandler.hpp +++ b/src/util/SignalsHandler.hpp @@ -60,7 +60,7 @@ public: */ SignalsHandler( util::config::ClioConfigDefinition const& config, - std::function forceExitHandler = kDEFAULT_FORCE_EXIT_HANDLER + std::function forceExitHandler = kDefaultForceExitHandler ); SignalsHandler(SignalsHandler const&) = delete; @@ -96,7 +96,7 @@ public: void notifyGracefulShutdownComplete(); - static constexpr auto kHANDLED_SIGNALS = {SIGINT, SIGTERM}; + static constexpr auto kHandledSignals = {SIGINT, SIGTERM}; private: /** @@ -113,7 +113,7 @@ private: void runStateMachine(); - static constexpr auto kDEFAULT_FORCE_EXIT_HANDLER = []() { std::exit(EXIT_FAILURE); }; + static constexpr auto kDefaultForceExitHandler = []() { std::exit(EXIT_FAILURE); }; }; } // namespace util diff --git a/src/util/Spawn.hpp b/src/util/Spawn.hpp index c67f9e60c..a4781ef94 100644 --- a/src/util/Spawn.hpp +++ b/src/util/Spawn.hpp @@ -31,14 +31,14 @@ inline constexpr struct PropagatingCompletionHandler { if (ePtr) std::rethrow_exception(ePtr); } -} kPROPAGATE_EXCEPTIONS; +} kPropagateExceptions; } // namespace impl /** * @brief Spawns a coroutine using `boost::asio::spawn` * - * @note This uses kPROPAGATE_EXCEPTIONS to force asio to propagate exceptions through `io_context` + * @note This uses kPropagateExceptions to force asio to propagate exceptions through `io_context` * @note Since implicit strand was removed from boost::asio::spawn this helper function adds the * strand back * @@ -54,13 +54,13 @@ spawn(Ctx&& ctx, F&& func) { if constexpr (impl::IsStrand) { boost::asio::spawn( - std::forward(ctx), std::forward(func), impl::kPROPAGATE_EXCEPTIONS + std::forward(ctx), std::forward(func), impl::kPropagateExceptions ); } else { boost::asio::spawn( boost::asio::make_strand(std::forward(ctx).get_executor()), std::forward(func), - impl::kPROPAGATE_EXCEPTIONS + impl::kPropagateExceptions ); } } diff --git a/src/util/Taggable.cpp b/src/util/Taggable.cpp index 0cd3632ce..ac6cf07b6 100644 --- a/src/util/Taggable.cpp +++ b/src/util/Taggable.cpp @@ -11,18 +11,18 @@ namespace util::impl { UIntTagGenerator::TagType UIntTagGenerator::next() { - static std::atomic_uint64_t kNUM{0}; - return kNUM++; + static std::atomic_uint64_t kNum{0}; + return kNum++; } UUIDTagGenerator::TagType UUIDTagGenerator::next() { - static boost::uuids::random_generator kGEN{}; - static std::mutex kMTX{}; + static boost::uuids::random_generator kGen{}; + static std::mutex kMtx{}; - std::scoped_lock const lk(kMTX); - return kGEN(); + std::scoped_lock const lk(kMtx); + return kGen(); } } // namespace util::impl diff --git a/src/util/TxUtils.cpp b/src/util/TxUtils.cpp index 6a4c91581..e424d70a4 100644 --- a/src/util/TxUtils.cpp +++ b/src/util/TxUtils.cpp @@ -17,7 +17,7 @@ namespace util { [[nodiscard]] std::unordered_set const& getTxTypesInLowercase() { - static std::unordered_set const kTYPES_KEYS_IN_LOWERCASE = []() { + static std::unordered_set const kTypesKeysInLowercase = []() { std::unordered_set keys; std::transform( ripple::TxFormats::getInstance().begin(), @@ -28,6 +28,6 @@ getTxTypesInLowercase() return keys; }(); - return kTYPES_KEYS_IN_LOWERCASE; + return kTypesKeysInLowercase; } } // namespace util diff --git a/src/util/async/context/BasicExecutionContext.hpp b/src/util/async/context/BasicExecutionContext.hpp index d08de5d99..13c031fed 100644 --- a/src/util/async/context/BasicExecutionContext.hpp +++ b/src/util/async/context/BasicExecutionContext.hpp @@ -120,8 +120,7 @@ class BasicExecutionContext : public ExecutionContextTag { public: /** @brief Whether operations on this execution context are noexcept */ - static constexpr bool kIS_NOEXCEPT = - noexcept(ErrorHandlerType::wrap([](auto&) { throw 0; })) and + static constexpr bool kIsNoexcept = noexcept(ErrorHandlerType::wrap([](auto&) { throw 0; })) and noexcept(ErrorHandlerType::catchAndAssert([] { throw 0; })); using ContextHolderType = ContextType; @@ -190,7 +189,7 @@ public: SomeStdDuration auto delay, SomeHandlerWith auto&& fn, std::optional timeout = std::nullopt - ) noexcept(kIS_NOEXCEPT) + ) noexcept(kIsNoexcept) { if constexpr (not std::is_same_v< decltype(TimerContextProvider::getContext(*this)), @@ -235,7 +234,7 @@ public: SomeStdDuration auto delay, SomeHandlerWith auto&& fn, std::optional timeout = std::nullopt - ) noexcept(kIS_NOEXCEPT) + ) noexcept(kIsNoexcept) { if constexpr (not std::is_same_v< decltype(TimerContextProvider::getContext(*this)), @@ -283,7 +282,7 @@ public: executeRepeatedly( SomeStdDuration auto interval, SomeHandlerWithoutStopToken auto&& fn - ) noexcept(kIS_NOEXCEPT) + ) noexcept(kIsNoexcept) { if constexpr (not std::is_same_v< decltype(TimerContextProvider::getContext(*this)), @@ -309,7 +308,7 @@ public: execute( SomeHandlerWith auto&& fn, std::optional timeout = std::nullopt - ) noexcept(kIS_NOEXCEPT) + ) noexcept(kIsNoexcept) { return DispatcherType::dispatch( context_, @@ -343,7 +342,7 @@ public: */ [[nodiscard]] auto execute(SomeHandlerWith auto&& fn, SomeStdDuration auto timeout) noexcept( - kIS_NOEXCEPT + kIsNoexcept ) { return execute( @@ -360,7 +359,7 @@ public: * @return A unstoppable operation that can be used to wait for the result */ [[nodiscard]] auto - execute(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIS_NOEXCEPT) + execute(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIsNoexcept) { return DispatcherType::dispatch( context_, @@ -384,7 +383,7 @@ public: * @param fn The block of code to execute */ void - submit(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIS_NOEXCEPT) + submit(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIsNoexcept) { DispatcherType::post(context_, ErrorHandlerType::catchAndAssert(fn)); } diff --git a/src/util/async/context/SystemExecutionContext.hpp b/src/util/async/context/SystemExecutionContext.hpp index cb9ec0c3a..01eb2ac9e 100644 --- a/src/util/async/context/SystemExecutionContext.hpp +++ b/src/util/async/context/SystemExecutionContext.hpp @@ -20,8 +20,8 @@ public: [[nodiscard]] static auto& instance() { - static util::async::PoolExecutionContext kSYSTEM_EXECUTION_CONTEXT{}; - return kSYSTEM_EXECUTION_CONTEXT; + static util::async::PoolExecutionContext kSystemExecutionContext{}; + return kSystemExecutionContext; } }; diff --git a/src/util/async/context/impl/Strand.hpp b/src/util/async/context/impl/Strand.hpp index f5db35cae..88a75c129 100644 --- a/src/util/async/context/impl/Strand.hpp +++ b/src/util/async/context/impl/Strand.hpp @@ -27,7 +27,7 @@ class BasicStrand { friend AssociatedExecutorExtractor; public: - static constexpr bool kIS_NOEXCEPT = noexcept(ErrorHandlerType::wrap([](auto&) { throw 0; })); + static constexpr bool kIsNoexcept = noexcept(ErrorHandlerType::wrap([](auto&) { throw 0; })); using ContextHolderType = typename ParentContextType::ContextHolderType::Strand; using ExecutorType = typename ContextHolderType::Executor; @@ -50,7 +50,7 @@ public: execute( SomeHandlerWith auto&& fn, std::optional timeout = std::nullopt - ) noexcept(kIS_NOEXCEPT) + ) noexcept(kIsNoexcept) { return DispatcherType::dispatch( context_, @@ -77,7 +77,7 @@ public: [[nodiscard]] auto execute(SomeHandlerWith auto&& fn, SomeStdDuration auto timeout) noexcept( - kIS_NOEXCEPT + kIsNoexcept ) { return execute( @@ -87,7 +87,7 @@ public: } [[nodiscard]] auto - execute(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIS_NOEXCEPT) + execute(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIsNoexcept) { return DispatcherType::dispatch( context_, @@ -108,7 +108,7 @@ public: executeRepeatedly( SomeStdDuration auto interval, SomeHandlerWithoutStopToken auto&& fn - ) noexcept(kIS_NOEXCEPT) + ) noexcept(kIsNoexcept) { if constexpr (not std::is_same_v< decltype(TimerContextProvider::getContext(*this)), @@ -124,7 +124,7 @@ public: } void - submit(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIS_NOEXCEPT) + submit(SomeHandlerWithoutStopToken auto&& fn) noexcept(kIsNoexcept) { DispatcherType::post(context_, ErrorHandlerType::catchAndAssert(fn)); } diff --git a/src/util/build/Build.cpp b/src/util/build/Build.cpp index d92fbf057..9a8773dc7 100644 --- a/src/util/build/Build.cpp +++ b/src/util/build/Build.cpp @@ -17,44 +17,44 @@ namespace util::build { #error "BUILD_DATE must be defined" #endif -static constexpr char kVERSION_STRING[] = CLIO_VERSION; -static constexpr char kGIT_COMMIT_HASH[] = GIT_COMMIT_HASH; -static constexpr char kGIT_BUILD_BRANCH[] = GIT_BUILD_BRANCH; -static constexpr char kBUILD_DATE[] = BUILD_DATE; +static constexpr char kVersionString[] = CLIO_VERSION; +static constexpr char kGitCommitHash[] = GIT_COMMIT_HASH; +static constexpr char kGitBuildBranch[] = GIT_BUILD_BRANCH; +static constexpr char kBuildDate[] = BUILD_DATE; std::string const& getClioVersionString() { - static std::string const kVALUE = kVERSION_STRING; - return kVALUE; + static std::string const kValue = kVersionString; + return kValue; } std::string const& getClioFullVersionString() { - static std::string const kVALUE = "clio-" + getClioVersionString(); - return kVALUE; + static std::string const kValue = "clio-" + getClioVersionString(); + return kValue; } std::string const& getGitCommitHash() { - static std::string const kVALUE = kGIT_COMMIT_HASH; - return kVALUE; + static std::string const kValue = kGitCommitHash; + return kValue; } std::string const& getGitBuildBranch() { - static std::string const kVALUE = kGIT_BUILD_BRANCH; - return kVALUE; + static std::string const kValue = kGitBuildBranch; + return kValue; } std::string const& getBuildDate() { - static std::string const kVALUE = kBUILD_DATE; - return kVALUE; + static std::string const kValue = kBuildDate; + return kValue; } } // namespace util::build diff --git a/src/util/config/Array.cpp b/src/util/config/Array.cpp index e274a696e..44a132924 100644 --- a/src/util/config/Array.cpp +++ b/src/util/config/Array.cpp @@ -20,10 +20,10 @@ Array::Array(ConfigValue arg) : itemPattern_{std::move(arg)} std::string_view Array::prefix(std::string_view key) { - static constexpr std::string_view kARRAY_SUFFIX = ".[]"; - ASSERT(key.contains(kARRAY_SUFFIX), "Provided key is not an array key: {}", key); + static constexpr std::string_view kArraySuffix = ".[]"; + ASSERT(key.contains(kArraySuffix), "Provided key is not an array key: {}", key); - return key.substr(0, key.rfind(kARRAY_SUFFIX) + kARRAY_SUFFIX.size()); + return key.substr(0, key.rfind(kArraySuffix) + kArraySuffix.size()); } std::optional diff --git a/src/util/config/ConfigConstraints.cpp b/src/util/config/ConfigConstraints.cpp index 82a8ec0b1..4c384e138 100644 --- a/src/util/config/ConfigConstraints.cpp +++ b/src/util/config/ConfigConstraints.cpp @@ -36,7 +36,7 @@ PortConstraint::checkValueImpl(Value const& port) const } else { p = static_cast(std::get(port)); } - if (p >= kPORT_MIN && p <= kPORT_MAX) + if (p >= kPortMin && p <= kPortMax) return std::nullopt; return Error{"Port does not satisfy the constraint bounds"}; } @@ -57,11 +57,11 @@ ValidIPConstraint::checkValueImpl(Value const& ip) const if (not errorCode.failed()) return std::nullopt; - static std::regex const kHOST{ + static std::regex const kHost{ R"regex(^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$)regex" }; - if (std::regex_match(std::get(ip), kHOST)) + if (std::regex_match(std::get(ip), kHost)) return std::nullopt; return Error{"Ip is not a valid ip address or hostname"}; diff --git a/src/util/config/ConfigConstraints.hpp b/src/util/config/ConfigConstraints.hpp index bf60e50d0..766d96cef 100644 --- a/src/util/config/ConfigConstraints.hpp +++ b/src/util/config/ConfigConstraints.hpp @@ -26,7 +26,7 @@ class ConfigValue; /** * @brief specific values that are accepted for logger levels in config. */ -static constexpr std::array kLOG_LEVELS = { +static constexpr std::array kLogLevels = { "trace", "debug", "info", @@ -38,7 +38,7 @@ static constexpr std::array kLOG_LEVELS = { /** * @brief specific values that are accepted for logger tag style in config. */ -static constexpr std::array kLOG_TAGS = { +static constexpr std::array kLogTags = { "int", "uint", "null", @@ -49,7 +49,7 @@ static constexpr std::array kLOG_TAGS = { /** * @brief specific values that are accepted for cache loading in config. */ -static constexpr std::array kLOAD_CACHE_MODE = { +static constexpr std::array kLoadCacheMode = { "sync", "async", "none", @@ -58,17 +58,17 @@ static constexpr std::array kLOAD_CACHE_MODE = { /** * @brief specific values that are accepted for database type in config. */ -static constexpr std::array kDATABASE_TYPE = {"cassandra"}; +static constexpr std::array kDatabaseType = {"cassandra"}; /** * @brief specific values that are accepted for server's processing_policy in config. */ -static constexpr std::array kPROCESSING_POLICY = {"parallel", "sequent"}; +static constexpr std::array kProcessingPolicy = {"parallel", "sequent"}; /** * @brief specific values that are accepted for database provider in config. */ -static constexpr std::array kPROVIDER = {"cassandra", "aws_keyspace"}; +static constexpr std::array kProvider = {"cassandra", "aws_keyspace"}; /** * @brief An interface to enforce constraints on certain values within ClioConfigDefinition. @@ -199,12 +199,12 @@ private: print(std::ostream& stream) const override { stream << fmt::format( - "The minimum value is `{}`. The maximum value is `{}`.", kPORT_MIN, kPORT_MAX + "The minimum value is `{}`. The maximum value is `{}`.", kPortMin, kPortMax ); } - static constexpr uint32_t kPORT_MIN = 1; - static constexpr uint32_t kPORT_MAX = 65535; + static constexpr uint32_t kPortMin = 1; + static constexpr uint32_t kPortMax = 65535; }; /** @@ -462,13 +462,13 @@ private: static constinit PortConstraint gValidatePort{}; static constinit ValidIPConstraint gValidateIp{}; -static constinit OneOf gValidateChannelName{"channel", Logger::kCHANNELS}; -static constinit OneOf gValidateLogLevelName{"log.level", kLOG_LEVELS}; -static constinit OneOf gValidateCassandraName{"database.type", kDATABASE_TYPE}; -static constinit OneOf gValidateLoadMode{"cache.load", kLOAD_CACHE_MODE}; -static constinit OneOf gValidateLogTag{"log.tag_style", kLOG_TAGS}; -static constinit OneOf gValidateProcessingPolicy{"server.processing_policy", kPROCESSING_POLICY}; -static constinit OneOf gValidateProvider{"database.cassandra.provider", kPROVIDER}; +static constinit OneOf gValidateChannelName{"channel", Logger::kChannels}; +static constinit OneOf gValidateLogLevelName{"log.level", kLogLevels}; +static constinit OneOf gValidateCassandraName{"database.type", kDatabaseType}; +static constinit OneOf gValidateLoadMode{"cache.load", kLoadCacheMode}; +static constinit OneOf gValidateLogTag{"log.tag_style", kLogTags}; +static constinit OneOf gValidateProcessingPolicy{"server.processing_policy", kProcessingPolicy}; +static constinit OneOf gValidateProvider{"database.cassandra.provider", kProvider}; static constinit PositiveDouble gValidatePositiveDouble{}; @@ -498,8 +498,8 @@ static constinit NumberValueConstraint gValidateNonNegativeUint32{ std::numeric_limits::max() }; static constinit NumberValueConstraint gValidateApiVersion{ - rpc::kAPI_VERSION_MIN, - rpc::kAPI_VERSION_MAX + rpc::kApiVersionMin, + rpc::kApiVersionMax }; static constinit RpcNameConstraint gRpcNameConstraint{}; diff --git a/src/util/config/ConfigDefinition.cpp b/src/util/config/ConfigDefinition.cpp index e6a51177c..7166067fe 100644 --- a/src/util/config/ConfigDefinition.cpp +++ b/src/util/config/ConfigDefinition.cpp @@ -110,7 +110,7 @@ ClioConfigDefinition::toMilliseconds(float value) { ASSERT(value >= 0.0f, "Floating point value of seconds must be non-negative, got: {}", value); return std::chrono::milliseconds{ - std::lroundf(value * static_cast(util::kMILLISECONDS_PER_SECOND)) + std::lroundf(value * static_cast(util::kMillisecondsPerSecond)) }; } @@ -242,7 +242,7 @@ ClioConfigDefinition::parse(ConfigFileInterface const& config) ClioConfigDefinition& getClioConfig() { - static ClioConfigDefinition kCLIO_CONFIG{ + static ClioConfigDefinition kClioConfig{ {{"database.type", ConfigValue{ConfigType::String} .defaultValue("cassandra") @@ -444,15 +444,15 @@ getClioConfig() {"api_version.default", ConfigValue{ConfigType::Integer} - .defaultValue(rpc::kAPI_VERSION_DEFAULT) + .defaultValue(rpc::kApiVersionDefault) .withConstraint(gValidateApiVersion)}, {"api_version.min", ConfigValue{ConfigType::Integer} - .defaultValue(rpc::kAPI_VERSION_MIN) + .defaultValue(rpc::kApiVersionMin) .withConstraint(gValidateApiVersion)}, {"api_version.max", ConfigValue{ConfigType::Integer} - .defaultValue(rpc::kAPI_VERSION_MAX) + .defaultValue(rpc::kApiVersionMax) .withConstraint(gValidateApiVersion)}, {"migration.full_scan_threads", @@ -463,7 +463,7 @@ getClioConfig() ConfigValue{ConfigType::Integer}.defaultValue(100).withConstraint(gValidateUint32)}}, }; - return kCLIO_CONFIG; + return kClioConfig; } } // namespace util::config diff --git a/src/util/config/ConfigDescription.hpp b/src/util/config/ConfigDescription.hpp index a66b021ef..69e52f046 100644 --- a/src/util/config/ConfigDescription.hpp +++ b/src/util/config/ConfigDescription.hpp @@ -49,8 +49,8 @@ public: get(std::string_view key) { auto const itr = - std::ranges::find_if(kCONFIG_DESCRIPTION, [&](auto const& v) { return v.key == key; }); - ASSERT(itr != kCONFIG_DESCRIPTION.end(), "Key {} doesn't exist in config", key); + std::ranges::find_if(kConfigDescription, [&](auto const& v) { return v.key == key; }); + ASSERT(itr != kConfigDescription.end(), "Key {} doesn't exist in config", key); return itr->value; } @@ -95,9 +95,9 @@ public: static void writeConfigDescriptionToFile(std::ostream& file) { - file << kCONFIG_DESCRIPTION_HEADER; + file << kConfigDescriptionHeader; - for (auto const& [key, val] : kCONFIG_DESCRIPTION) { + for (auto const& [key, val] : kConfigDescription) { file << "\n### " << key << "\n\n"; // Every type of value is directed to operator<< in ConfigValue.hpp @@ -112,7 +112,7 @@ public: } private: - static constexpr auto kCONFIG_DESCRIPTION_HEADER = + static constexpr auto kConfigDescriptionHeader = R"(# Clio Config Description This document provides a list of all available Clio configuration properties in detail. @@ -125,7 +125,7 @@ This document provides a list of all available Clio configuration properties in ## Configuration Details )"; - static constexpr auto kCONFIG_DESCRIPTION = std::array{ + static constexpr auto kConfigDescription = std::array{ KV{.key = "database.type", .value = "Specifies the type of database used for storing and retrieving data required " "by the Clio server. Both " diff --git a/src/util/log/Logger.cpp b/src/util/log/Logger.cpp index 2634fd478..a97b77e58 100644 --- a/src/util/log/Logger.cpp +++ b/src/util/log/Logger.cpp @@ -69,7 +69,7 @@ toSpdlogLevel(Severity sev) std::string_view toString(Severity sev) { - static constexpr std::array kLABELS = { + static constexpr std::array kLabels = { "TRC", "DBG", "NFO", @@ -78,7 +78,7 @@ toString(Severity sev) "FTL", }; - return kLABELS.at(static_cast(sev)); + return kLabels.at(static_cast(sev)); } } // namespace @@ -215,7 +215,7 @@ static std::expected, std::string getMinSeverity(config::ClioConfigDefinition const& config, Severity defaultSeverity) { std::unordered_map minSeverity; - for (auto const& channel : Logger::kCHANNELS) + for (auto const& channel : Logger::kChannels) minSeverity[channel] = defaultSeverity; auto const overrides = config.getArray("log.channels"); @@ -225,7 +225,7 @@ getMinSeverity(config::ClioConfigDefinition const& config, Severity defaultSever ++it) { auto const& channelConfig = *it; auto const name = channelConfig.get("channel"); - if (not std::ranges::contains(Logger::kCHANNELS, name)) { + if (not std::ranges::contains(Logger::kChannels, name)) { return std::unexpected{ fmt::format("Can't override settings for log channel {}: invalid channel", name) }; @@ -258,9 +258,9 @@ LogServiceState::init( }); if (isAsync) { - static constexpr size_t kQUEUE_SIZE = 8192; - static constexpr size_t kTHREAD_COUNT = 1; - spdlog::init_thread_pool(kQUEUE_SIZE, kTHREAD_COUNT); + static constexpr size_t kQueueSize = 8192; + static constexpr size_t kThreadCount = 1; + spdlog::init_thread_pool(kQueueSize, kThreadCount); } } @@ -382,7 +382,7 @@ LogService::init(config::ClioConfigDefinition const& config) auto const minSeverity = std::move(maybeMinSeverity).value(); // Create loggers for each channel - for (auto const& channel : Logger::kCHANNELS) { + for (auto const& channel : Logger::kChannels) { auto const it = minSeverity.find(channel); auto const severity = (it != minSeverity.end()) ? it->second : defaultSeverity_; registerLogger(channel, severity); @@ -454,14 +454,14 @@ Logger::Logger(std::string_view const channel) : logger_(LogServiceState::regist Logger::~Logger() { // One reference is held by logger_ and the other by spdlog registry - static constexpr size_t kLAST_LOGGER_REF_COUNT = 2; + static constexpr size_t kLastLoggerRefCount = 2; if (logger_ == nullptr) { return; } - bool const isDynamic = !std::ranges::contains(kCHANNELS, logger_->name()); - if (isDynamic && logger_.use_count() == kLAST_LOGGER_REF_COUNT) { + bool const isDynamic = !std::ranges::contains(kChannels, logger_->name()); + if (isDynamic && logger_.use_count() == kLastLoggerRefCount) { spdlog::drop(logger_->name()); } } diff --git a/src/util/log/Logger.hpp b/src/util/log/Logger.hpp index 4dbe04715..09ebd42a5 100644 --- a/src/util/log/Logger.hpp +++ b/src/util/log/Logger.hpp @@ -130,7 +130,7 @@ class Logger { }; public: - static constexpr std::array kCHANNELS = { + static constexpr std::array kChannels = { "General", "WebServer", "Backend", diff --git a/src/util/requests/RequestBuilder.cpp b/src/util/requests/RequestBuilder.cpp index fd3e3748e..dafdbf14a 100644 --- a/src/util/requests/RequestBuilder.cpp +++ b/src/util/requests/RequestBuilder.cpp @@ -185,7 +185,7 @@ RequestBuilder::doRequestImpl( request_.method(method); - if constexpr (StreamDataType::kSSL_ENABLED) { + if constexpr (StreamDataType::kSslEnabled) { beast::get_lowest_layer(stream).expires_after(timeout_); stream.async_handshake(asio::ssl::stream_base::client, yield[errorCode]); if (errorCode) diff --git a/src/util/requests/RequestBuilder.hpp b/src/util/requests/RequestBuilder.hpp index ad8622f6f..15773c168 100644 --- a/src/util/requests/RequestBuilder.hpp +++ b/src/util/requests/RequestBuilder.hpp @@ -27,7 +27,7 @@ class RequestBuilder { util::Logger log_{"RequestBuilder"}; std::string host_; std::string port_; - std::chrono::milliseconds timeout_{kDEFAULT_TIMEOUT}; + std::chrono::milliseconds timeout_{kDefaultTimeout}; boost::beast::http::request request_; public: @@ -168,7 +168,7 @@ public: std::expected post(boost::asio::yield_context yield); - static constexpr std::chrono::milliseconds kDEFAULT_TIMEOUT{ + static constexpr std::chrono::milliseconds kDefaultTimeout{ 30000 }; /**< Default timeout for requests */ diff --git a/src/util/requests/WsConnection.cpp b/src/util/requests/WsConnection.cpp index 95b5eb833..8a673d9c4 100644 --- a/src/util/requests/WsConnection.cpp +++ b/src/util/requests/WsConnection.cpp @@ -142,7 +142,7 @@ WsConnectionBuilder::connectImpl(StreamDataType&& streamData, asio::yield_contex if (errorCode) return std::unexpected{RequestError{"Connect error", errorCode}}; - if constexpr (StreamDataType::kSSL_ENABLED) { + if constexpr (StreamDataType::kSslEnabled) { beast::get_lowest_layer(ws).expires_after(connectionTimeout_); ws.next_layer().async_handshake(asio::ssl::stream_base::client, yield[errorCode]); if (errorCode) @@ -166,7 +166,7 @@ WsConnectionBuilder::connectImpl(StreamDataType&& streamData, asio::yield_contex if (errorCode) return std::unexpected{RequestError{"Handshake error", errorCode}}; - if constexpr (StreamDataType::kSSL_ENABLED) { + if constexpr (StreamDataType::kSslEnabled) { return std::make_unique(std::move(ws)); } else { return std::make_unique(std::move(ws)); diff --git a/src/util/requests/WsConnection.hpp b/src/util/requests/WsConnection.hpp index 709bd024f..6fa9c7b10 100644 --- a/src/util/requests/WsConnection.hpp +++ b/src/util/requests/WsConnection.hpp @@ -69,12 +69,10 @@ public: virtual std::optional close( boost::asio::yield_context yield, - std::chrono::steady_clock::duration timeout = kDEFAULT_TIMEOUT + std::chrono::steady_clock::duration timeout = kDefaultTimeout ) = 0; - static constexpr std::chrono::seconds kDEFAULT_TIMEOUT{ - 5 - }; /**< Default timeout for connecting */ + static constexpr std::chrono::seconds kDefaultTimeout{5}; /**< Default timeout for connecting */ }; using WsConnectionPtr = std::unique_ptr; @@ -86,8 +84,8 @@ class WsConnectionBuilder { std::string host_; std::string port_; std::vector headers_; - std::chrono::steady_clock::duration connectionTimeout_{kDEFAULT_TIMEOUT}; - std::chrono::steady_clock::duration wsHandshakeTimeout_{kDEFAULT_TIMEOUT}; + std::chrono::steady_clock::duration connectionTimeout_{kDefaultTimeout}; + std::chrono::steady_clock::duration wsHandshakeTimeout_{kDefaultTimeout}; std::string target_{"/"}; public: @@ -171,9 +169,7 @@ public: [[nodiscard]] std::expected connect(boost::asio::yield_context yield) const; - static constexpr std::chrono::seconds kDEFAULT_TIMEOUT{ - 5 - }; /**< Default timeout for connecting */ + static constexpr std::chrono::seconds kDefaultTimeout{5}; /**< Default timeout for connecting */ private: template diff --git a/src/util/requests/impl/SslContext.cpp b/src/util/requests/impl/SslContext.cpp index 511448a9c..b433f9f0e 100644 --- a/src/util/requests/impl/SslContext.cpp +++ b/src/util/requests/impl/SslContext.cpp @@ -31,7 +31,7 @@ namespace { // Taken from https://go.dev/src/crypto/x509/root_linux.go -constexpr std::array kCERT_FILE_PATHS{ +constexpr std::array kCertFilePaths{ "/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu/Gentoo etc. "/etc/pki/tls/certs/ca-bundle.crt", // Fedora/RHEL 6 "/etc/ssl/ca-bundle.pem", // OpenSUSE @@ -46,7 +46,7 @@ constexpr std::array kCERT_FILE_PATHS{ std::expected getRootCertificate() { - for (auto const& path : kCERT_FILE_PATHS) { + for (auto const& path : kCertFilePaths) { if (std::filesystem::exists(path)) { std::ifstream const fileStream{path, std::ios::in}; if (not fileStream.is_open()) { @@ -89,8 +89,8 @@ sslErrorToString(boost::beast::error_code const& error) boost::lexical_cast(ERR_GET_REASON(error.value())) ); - static constexpr size_t kBUFFER_SIZE = 128; - char buf[kBUFFER_SIZE]; + static constexpr size_t kBufferSize = 128; + char buf[kBufferSize]; ::ERR_error_string_n(error.value(), buf, sizeof(buf)); errorString += buf; diff --git a/src/util/requests/impl/StreamData.hpp b/src/util/requests/impl/StreamData.hpp index 6834fb198..d7f84a8ab 100644 --- a/src/util/requests/impl/StreamData.hpp +++ b/src/util/requests/impl/StreamData.hpp @@ -20,7 +20,7 @@ namespace util::requests::impl { template struct PlainStreamData { - static constexpr bool kSSL_ENABLED = false; + static constexpr bool kSslEnabled = false; explicit PlainStreamData(boost::asio::yield_context yield) : stream(boost::asio::get_associated_executor(yield)) @@ -38,7 +38,7 @@ class SslStreamData { boost::asio::ssl::context sslContext_; public: - static constexpr bool kSSL_ENABLED = true; + static constexpr bool kSslEnabled = true; static std::expected create(boost::asio::yield_context yield) diff --git a/src/util/requests/impl/WsConnectionImpl.hpp b/src/util/requests/impl/WsConnectionImpl.hpp index eff8a654a..8df7a4a4a 100644 --- a/src/util/requests/impl/WsConnectionImpl.hpp +++ b/src/util/requests/impl/WsConnectionImpl.hpp @@ -88,7 +88,7 @@ public: std::optional close( boost::asio::yield_context yield, - std::chrono::steady_clock::duration const timeout = kDEFAULT_TIMEOUT + std::chrono::steady_clock::duration const timeout = kDefaultTimeout ) override { // Set the timeout for closing the connection diff --git a/src/web/AdminVerificationStrategy.cpp b/src/web/AdminVerificationStrategy.cpp index ca7687f00..382e6ac33 100644 --- a/src/web/AdminVerificationStrategy.cpp +++ b/src/web/AdminVerificationStrategy.cpp @@ -35,12 +35,12 @@ PasswordAdminVerificationStrategy::isAdmin(RequestHeader const& request, std::st return false; } auto userAuth = it->value(); - if (!userAuth.starts_with(kPASSWORD_PREFIX)) { + if (!userAuth.starts_with(kPasswordPrefix)) { // Invalid Authorization header return false; } - userAuth.remove_prefix(kPASSWORD_PREFIX.size()); + userAuth.remove_prefix(kPasswordPrefix.size()); return passwordSha256_ == util::toUpper(userAuth); } diff --git a/src/web/AdminVerificationStrategy.hpp b/src/web/AdminVerificationStrategy.hpp index d32ee3639..0f74639b4 100644 --- a/src/web/AdminVerificationStrategy.hpp +++ b/src/web/AdminVerificationStrategy.hpp @@ -60,7 +60,7 @@ public: /** * @brief The prefix for the password in the request header. */ - static constexpr std::string_view kPASSWORD_PREFIX = "Password "; + static constexpr std::string_view kPasswordPrefix = "Password "; /** * @brief Construct a new PasswordAdminVerificationStrategy object diff --git a/src/web/PlainWsSession.hpp b/src/web/PlainWsSession.hpp index de53d1b10..a5cb7c853 100644 --- a/src/web/PlainWsSession.hpp +++ b/src/web/PlainWsSession.hpp @@ -155,8 +155,8 @@ private: { parser_.emplace(); - static constexpr auto kMAX_BODY_SIZE = 10000; - parser_->body_limit(kMAX_BODY_SIZE); + static constexpr auto kMaxBodySize = 10000; + parser_->body_limit(kMaxBodySize); boost::beast::get_lowest_layer(http_).expires_after(std::chrono::seconds(30)); onUpgrade(); diff --git a/src/web/ProxyIpResolver.cpp b/src/web/ProxyIpResolver.cpp index 04b82a294..5716a2ae3 100644 --- a/src/web/ProxyIpResolver.cpp +++ b/src/web/ProxyIpResolver.cpp @@ -57,7 +57,7 @@ ProxyIpResolver::resolveClientIp(std::string const& connectionIp, HttpHeaders co return extractClientIp(headers); } - if (auto it = headers.find(kPROXY_TOKEN_HEADER); it != headers.end()) { + if (auto it = headers.find(kProxyTokenHeader); it != headers.end()) { auto const tokenHash = util::sha256sum(it->value()); if (proxyTokens_.contains(tokenHash)) { return extractClientIp(headers); @@ -78,22 +78,22 @@ ProxyIpResolver::extractClientIp(HttpHeaders const& headers) // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Forwarded#using_the_forwarded_header auto const headerValue = util::toLower(it->value()); - static constexpr std::string_view kFOR_PREFIX = "for="; - auto const startPos = headerValue.rfind(kFOR_PREFIX); + static constexpr std::string_view kForPrefix = "for="; + auto const startPos = headerValue.rfind(kForPrefix); if (startPos == std::string::npos) { return std::nullopt; } - auto value = it->value().substr(startPos + kFOR_PREFIX.size()); + auto value = it->value().substr(startPos + kForPrefix.size()); - static constexpr char kSECTION_DELIMITER = ';'; - static constexpr char kCHAIN_DELIMITER = ','; - auto const sectionEnd = value.find(kSECTION_DELIMITER); - auto const chainEnd = value.find(kCHAIN_DELIMITER); + static constexpr char kSectionDelimiter = ';'; + static constexpr char kChainDelimiter = ','; + auto const sectionEnd = value.find(kSectionDelimiter); + auto const chainEnd = value.find(kChainDelimiter); auto const endPos = std::min(sectionEnd, chainEnd); auto const ip = value.substr(0, endPos); - static constexpr auto kMIN_IP_LENGTH = 7; // minimum 3 dots + 4 digits - if (ip.size() < kMIN_IP_LENGTH) { + static constexpr auto kMinIpLength = 7; // minimum 3 dots + 4 digits + if (ip.size() < kMinIpLength) { return std::nullopt; } diff --git a/src/web/ProxyIpResolver.hpp b/src/web/ProxyIpResolver.hpp index 016e782ea..df7b09962 100644 --- a/src/web/ProxyIpResolver.hpp +++ b/src/web/ProxyIpResolver.hpp @@ -52,7 +52,7 @@ public: using HttpHeaders = boost::beast::http::request::header_type; - static constexpr std::string_view kPROXY_TOKEN_HEADER = "X-Proxy-Token"; + static constexpr std::string_view kProxyTokenHeader = "X-Proxy-Token"; /** * @brief Resolves the client's IP address from the connection IP and HTTP headers. diff --git a/src/web/SslWsSession.hpp b/src/web/SslWsSession.hpp index 50157a7d6..608bca657 100644 --- a/src/web/SslWsSession.hpp +++ b/src/web/SslWsSession.hpp @@ -160,8 +160,8 @@ private: parser_.emplace(); // Apply a reasonable limit to the allowed size of the body in bytes to prevent abuse. - static constexpr auto kMAX_BODY_SIZE = 10000; - parser_->body_limit(kMAX_BODY_SIZE); + static constexpr auto kMaxBodySize = 10000; + parser_->body_limit(kMaxBodySize); boost::beast::get_lowest_layer(https_).expires_after(std::chrono::seconds(30)); onUpgrade(); diff --git a/src/web/dosguard/WhitelistHandler.cpp b/src/web/dosguard/WhitelistHandler.cpp index 819ad8824..e7641d9b6 100644 --- a/src/web/dosguard/WhitelistHandler.cpp +++ b/src/web/dosguard/WhitelistHandler.cpp @@ -101,15 +101,15 @@ Whitelist::isInV6Subnet( bool Whitelist::isV4(std::string_view net) { - static std::regex const kIPV4_CIDR_REGEX(R"(^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/\d{1,2}$)"); - return std::regex_match(std::string(net), kIPV4_CIDR_REGEX); + static std::regex const kIpV4CidrRegex(R"(^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/\d{1,2}$)"); + return std::regex_match(std::string(net), kIpV4CidrRegex); } bool Whitelist::isV6(std::string_view net) { - static std::regex const kIPV6_CIDR_REGEX(R"(^([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}/\d{1,3}$)"); - return std::regex_match(std::string(net), kIPV6_CIDR_REGEX); + static std::regex const kIpV6CidrRegex(R"(^([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}/\d{1,3}$)"); + return std::regex_match(std::string(net), kIpV6CidrRegex); } bool diff --git a/src/web/impl/HttpBase.hpp b/src/web/impl/HttpBase.hpp index 41927c12f..09f7a509b 100644 --- a/src/web/impl/HttpBase.hpp +++ b/src/web/impl/HttpBase.hpp @@ -45,7 +45,7 @@ namespace web::impl { -static constexpr auto kHEALTH_CHECK_HTML = R"html( +static constexpr auto kHealthCheckHtml = R"html( Test page for Clio @@ -53,7 +53,7 @@ static constexpr auto kHEALTH_CHECK_HTML = R"html( )html"; -static constexpr auto kCACHE_CHECK_LOADED_HTML = R"html( +static constexpr auto kCacheCheckLoadedHtml = R"html( Cache state @@ -61,7 +61,7 @@ static constexpr auto kCACHE_CHECK_LOADED_HTML = R"html( )html"; -static constexpr auto kCACHE_CHECK_NOT_LOADED_HTML = R"html( +static constexpr auto kCacheCheckNotLoadedHtml = R"html( Cache state @@ -246,17 +246,15 @@ public: } if (req_.method() == http::verb::get and req_.target() == "/health") - return sender_(httpResponse(http::status::ok, "text/html", kHEALTH_CHECK_HTML)); + return sender_(httpResponse(http::status::ok, "text/html", kHealthCheckHtml)); if (req_.method() == http::verb::get and req_.target() == "/cache_state") { if (cache_.get().isFull()) { - return sender_( - httpResponse(http::status::ok, "text/html", kCACHE_CHECK_LOADED_HTML) - ); + return sender_(httpResponse(http::status::ok, "text/html", kCacheCheckLoadedHtml)); } return sender_(httpResponse( - http::status::service_unavailable, "text/html", kCACHE_CHECK_NOT_LOADED_HTML + http::status::service_unavailable, "text/html", kCacheCheckNotLoadedHtml )); } diff --git a/src/web/ng/Connection.hpp b/src/web/ng/Connection.hpp index f11abb50b..c67970943 100644 --- a/src/web/ng/Connection.hpp +++ b/src/web/ng/Connection.hpp @@ -121,8 +121,7 @@ public: * @note This value should be higher than forwarding timeout to not disconnect clients if * rippled is slow. */ - static constexpr std::chrono::steady_clock::duration kDEFAULT_TIMEOUT = - std::chrono::seconds{11}; + static constexpr std::chrono::steady_clock::duration kDefaultTimeout = std::chrono::seconds{11}; /** * @brief Construct a new Connection object diff --git a/src/web/ng/impl/ConnectionHandler.cpp b/src/web/ng/impl/ConnectionHandler.cpp index 61f9d3ccc..ef3552b39 100644 --- a/src/web/ng/impl/ConnectionHandler.cpp +++ b/src/web/ng/impl/ConnectionHandler.cpp @@ -164,7 +164,7 @@ ConnectionHandler::processConnection(ConnectionPtr connectionPtr, boost::asio::y } if (shouldCloseGracefully) { - connectionRef.setTimeout(kCLOSE_CONNECTION_TIMEOUT); + connectionRef.setTimeout(kCloseConnectionTimeout); connectionRef.close(yield); LOG(log_.trace()) << connectionRef.tag() << "Closed gracefully"; } @@ -195,7 +195,7 @@ ConnectionHandler::stopConnection(Connection& connection, boost::asio::yield_con connection }; connection.send(std::move(response), yield); - connection.setTimeout(kCLOSE_CONNECTION_TIMEOUT); + connection.setTimeout(kCloseConnectionTimeout); connection.close(yield); LOG(log.trace()) << connection.tag() << "Connection closed"; } diff --git a/src/web/ng/impl/ConnectionHandler.hpp b/src/web/ng/impl/ConnectionHandler.hpp index 203ca835d..31068ac7f 100644 --- a/src/web/ng/impl/ConnectionHandler.hpp +++ b/src/web/ng/impl/ConnectionHandler.hpp @@ -81,7 +81,7 @@ public: ConnectionHandler(ConnectionHandler&&) = delete; - static constexpr std::chrono::milliseconds kCLOSE_CONNECTION_TIMEOUT{500}; + static constexpr std::chrono::milliseconds kCloseConnectionTimeout{500}; void onGet(std::string const& target, MessageHandler handler); diff --git a/src/web/ng/impl/HttpConnection.hpp b/src/web/ng/impl/HttpConnection.hpp index 3f397cf15..ca1bdb7bb 100644 --- a/src/web/ng/impl/HttpConnection.hpp +++ b/src/web/ng/impl/HttpConnection.hpp @@ -59,7 +59,7 @@ template class HttpConnection : public UpgradableConnection { StreamType stream_; std::optional> request_; - std::chrono::steady_clock::duration timeout_{kDEFAULT_TIMEOUT}; + std::chrono::steady_clock::duration timeout_{kDefaultTimeout}; using MessageType = boost::beast::http::response; SendingQueue sendingQueue_; diff --git a/src/web/ng/impl/WsConnection.hpp b/src/web/ng/impl/WsConnection.hpp index 3e28183ba..b009ef74e 100644 --- a/src/web/ng/impl/WsConnection.hpp +++ b/src/web/ng/impl/WsConnection.hpp @@ -164,7 +164,7 @@ private: { // Disable the timeout. The websocket::stream uses its own timeout settings. boost::beast::get_lowest_layer(stream_).expires_never(); - setTimeout(kDEFAULT_TIMEOUT); + setTimeout(kDefaultTimeout); stream_.set_option( boost::beast::websocket::stream_base::decorator( [](boost::beast::websocket::response_type& res) { diff --git a/tests/common/etl/FakeDiffProvider.hpp b/tests/common/etl/FakeDiffProvider.hpp index eefb9429c..eeb6fc408 100644 --- a/tests/common/etl/FakeDiffProvider.hpp +++ b/tests/common/etl/FakeDiffProvider.hpp @@ -54,7 +54,7 @@ struct DiffProvider { keysMap->operator[](std::this_thread::get_id())++; if (keysMap->operator[](std::this_thread::get_id()) == keysSize - 1) { - return data::kLAST_KEY; + return data::kLastKey; } if (keysMap->operator[](std::this_thread::get_id()) == keysSize) { keysMap->operator[](std::this_thread::get_id()) = 0; diff --git a/tests/common/migration/TestMigrators.hpp b/tests/common/migration/TestMigrators.hpp index 6980b08fe..82a0fd5e9 100644 --- a/tests/common/migration/TestMigrators.hpp +++ b/tests/common/migration/TestMigrators.hpp @@ -5,9 +5,9 @@ struct SimpleTestMigrator { using Backend = MockMigrationBackend; - static constexpr auto kNAME = "SimpleTestMigrator"; - static constexpr auto kDESCRIPTION = "The migrator for version 0 -> 1"; - static constexpr auto kCAN_BLOCK_CLIO = true; + static constexpr auto kName = "SimpleTestMigrator"; + static constexpr auto kDescription = "The migrator for version 0 -> 1"; + static constexpr auto kCanBlockClio = true; static void runMigration(std::shared_ptr, util::config::ObjectView const&) @@ -17,8 +17,8 @@ struct SimpleTestMigrator { struct SimpleTestMigrator2 { using Backend = MockMigrationBackend; - static constexpr auto kNAME = "SimpleTestMigrator2"; - static constexpr auto kDESCRIPTION = "The migrator for version 1 -> 2"; + static constexpr auto kName = "SimpleTestMigrator2"; + static constexpr auto kDescription = "The migrator for version 1 -> 2"; static void runMigration(std::shared_ptr, util::config::ObjectView const&) { @@ -27,9 +27,9 @@ struct SimpleTestMigrator2 { struct SimpleTestMigrator3 { using Backend = MockMigrationBackend; - static constexpr auto kNAME = "SimpleTestMigrator3"; - static constexpr auto kDESCRIPTION = "The migrator for version 3 -> 4"; - static constexpr auto kCAN_BLOCK_CLIO = false; + static constexpr auto kName = "SimpleTestMigrator3"; + static constexpr auto kDescription = "The migrator for version 3 -> 4"; + static constexpr auto kCanBlockClio = false; static void runMigration(std::shared_ptr, util::config::ObjectView const&) diff --git a/tests/common/rpc/FakesAndMocks.hpp b/tests/common/rpc/FakesAndMocks.hpp index 789e26a8b..e277b68d6 100644 --- a/tests/common/rpc/FakesAndMocks.hpp +++ b/tests/common/rpc/FakesAndMocks.hpp @@ -60,12 +60,12 @@ public: { using namespace rpc::validation; - static auto const kRPC_SPEC = rpc::RpcSpec{ + static auto const kRpcSpec = rpc::RpcSpec{ {"hello", Required{}, Type{}, EqualTo{"world"}}, {"limit", Type{}, Between{0, 100}}, // optional field }; - return kRPC_SPEC; + return kRpcSpec; } static Result @@ -99,12 +99,12 @@ public: { using namespace rpc::validation; - static auto const kRPC_SPEC = rpc::RpcSpec{ + static auto const kRpcSpec = rpc::RpcSpec{ {"hello", Required{}, Type{}, EqualTo{"world"}}, {"limit", Type{}, Between{0u, 100u}}, // optional field }; - return kRPC_SPEC; + return kRpcSpec; } static Result diff --git a/tests/common/util/AsioContextTestFixture.hpp b/tests/common/util/AsioContextTestFixture.hpp index 381972cdb..c8329a74d 100644 --- a/tests/common/util/AsioContextTestFixture.hpp +++ b/tests/common/util/AsioContextTestFixture.hpp @@ -101,8 +101,8 @@ struct SyncAsioContextTest : virtual public ::testing::Test { void runContext() { - static constexpr auto kTIMEOUT = std::chrono::seconds{30}; - ctx_.run_for(kTIMEOUT); + static constexpr auto kTimeout = std::chrono::seconds{30}; + ctx_.run_for(kTimeout); ctx_.restart(); } diff --git a/tests/common/util/BinaryTestObject.cpp b/tests/common/util/BinaryTestObject.cpp index 63913ce65..20ecc9ada 100644 --- a/tests/common/util/BinaryTestObject.cpp +++ b/tests/common/util/BinaryTestObject.cpp @@ -25,8 +25,8 @@ namespace { -constinit auto const kSEQ = 30; -constinit auto const kRAW_HEADER = +constinit auto const kSeq = 30; +constinit auto const kRawHeader = "03C3141A01633CD656F91B4EBB5EB89B791BD34DBC8A04BB6F407C5335BC54351E" "DD733898497E809E04074D14D271E4832D7888754F9230800761563A292FA2315A" "6DB6FE30CC5909B285080FCD6773CC883F9FE0EE4D439340AC592AADB973ED3CF5" @@ -52,7 +52,7 @@ createTxAndMeta(std::string hashStr, std::string metaStr, std::string txnStr) auto const [metaBlob, txnBlob] = createTxAndMetaBlobs(metaStr, txnStr); ripple::SerialIter it{txnBlob.data(), txnBlob.size()}; - return {ripple::STTx{it}, ripple::TxMeta{hash, kSEQ, metaBlob}}; + return {ripple::STTx{it}, ripple::TxMeta{hash, kSeq, metaBlob}}; } etl::model::Transaction @@ -74,11 +74,11 @@ etl::model::Object createObject(etl::model::Object::ModType modType, std::string key) { // random object taken from initial ledger load - static constinit auto const kOBJ_PRED = + static constinit auto const kObjPred = "B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960A"; - static constinit auto const kOBJ_SUCC = + static constinit auto const kObjSucc = "B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960F"; - static constinit auto const kOBJ_BLOB = + static constinit auto const kObjBlob = "11007222002200002504270918370000000000000C4538000000000000000A554D94799200CC37EFAF45DA7670" "4ED3CBEDBB4B4FCD" "56E9CBA5399EB40A7B3BEC629546DD24CDB4C0004C4A5059000000000000000000000000000000000000000000" @@ -93,12 +93,12 @@ createObject(etl::model::Object::ModType modType, std::string key) .keyRaw = hexStringToBinaryString(key), .data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{} - : *ripple::strUnHex(kOBJ_BLOB), // NOLINT(bugprone-unchecked-optional-access) + : *ripple::strUnHex(kObjBlob), // NOLINT(bugprone-unchecked-optional-access) .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" - : hexStringToBinaryString(kOBJ_BLOB), - .successor = hexStringToBinaryString(kOBJ_SUCC), - .predecessor = hexStringToBinaryString(kOBJ_PRED), + : hexStringToBinaryString(kObjBlob), + .successor = hexStringToBinaryString(kObjSucc), + .predecessor = hexStringToBinaryString(kObjPred), .type = modType, }; } @@ -107,11 +107,11 @@ etl::model::Object createObjectWithBookBase(etl::model::Object::ModType modType, std::string key) { // random object taken from initial ledger load - static constinit auto const kOBJ_PRED = + static constinit auto const kObjPred = "B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960A"; - static constinit auto const kOBJ_SUCC = + static constinit auto const kObjSucc = "B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960F"; - static constinit auto const kOBJ_BLOB = + static constinit auto const kObjBlob = "11006422000000022505A681E855B4E076DD06D6D583804F9DC94F641337ECB97F71860300EEC17E530A2001D6" "C9583FFBFAD704E299BE" "3E544090ECCB12AF45FD03CAEEA852E5048E57F48FD45B505A0008138882D0F98C64A1A0E6D15053589771AD08" @@ -123,12 +123,12 @@ createObjectWithBookBase(etl::model::Object::ModType modType, std::string key) .keyRaw = hexStringToBinaryString(key), .data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{} - : *ripple::strUnHex(kOBJ_BLOB), // NOLINT(bugprone-unchecked-optional-access) + : *ripple::strUnHex(kObjBlob), // NOLINT(bugprone-unchecked-optional-access) .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" - : hexStringToBinaryString(kOBJ_BLOB), - .successor = hexStringToBinaryString(kOBJ_SUCC), - .predecessor = hexStringToBinaryString(kOBJ_PRED), + : hexStringToBinaryString(kObjBlob), + .successor = hexStringToBinaryString(kObjSucc), + .predecessor = hexStringToBinaryString(kObjPred), .type = modType, }; } @@ -141,19 +141,19 @@ createObjectWithTwoNFTs() ripple::Blob const uri1Blob(url1.begin(), url1.end()); ripple::Blob const uri2Blob(url2.begin(), url2.end()); - constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; - constexpr auto kNFT_ID = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; - constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; + constexpr auto kAccount = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; + constexpr auto kNftId = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; + constexpr auto kNftID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; - auto const nftPage = createNftTokenPage({{kNFT_ID, url1}, {kNFT_ID2, url2}}, std::nullopt); + auto const nftPage = createNftTokenPage({{kNftId, url1}, {kNftID2, url2}}, std::nullopt); auto const serializerNftPage = nftPage.getSerializer(); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); // key is a token made up from owner's account ID followed by unused (in Clio) value described // here: // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0020-non-fungible-tokens#tokenpage-id-format - constexpr auto kEXTRA_BYTES = "000000000000"; - auto const key = std::string(std::begin(account), std::end(account)) + kEXTRA_BYTES; + constexpr auto kExtraBytes = "000000000000"; + auto const key = std::string(std::begin(account), std::end(account)) + kExtraBytes; return { .key = {}, @@ -172,16 +172,16 @@ createObjectWithTwoNFTs() etl::model::Object createObjectWithMPT() { - constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; + constexpr auto kAccount = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; - auto const account = getAccountIdWithString(kACCOUNT); - auto const mptID = ripple::makeMptID(2, getAccountIdWithString(kACCOUNT)); - auto const mptokenObject = createMpTokenObject(kACCOUNT, mptID); + auto const account = getAccountIdWithString(kAccount); + auto const mptID = ripple::makeMptID(2, getAccountIdWithString(kAccount)); + auto const mptokenObject = createMpTokenObject(kAccount, mptID); // key is a token made up from several fields described here: // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0033-multi-purpose-tokens#2121-mptoken-ledger-identifier - constexpr auto kSPACE_KEY = 0x007F; - auto const keySha512Half = ripple::sha512Half(kSPACE_KEY, mptID, account); + constexpr auto kSpaceKey = 0x007F; + auto const keySha512Half = ripple::sha512Half(kSpaceKey, mptID, account); return { .key = {}, @@ -213,7 +213,7 @@ createSuccessor() etl::impl::PBLedgerResponseType createDataAndDiff() { - auto const rawHeaderBlob = hexStringToBinaryString(kRAW_HEADER); + auto const rawHeaderBlob = hexStringToBinaryString(kRawHeader); auto res = etl::impl::PBLedgerResponseType(); res.set_ledger_header(rawHeaderBlob); @@ -259,7 +259,7 @@ createDataAndDiff() etl::impl::PBLedgerResponseType createData() { - auto const rawHeaderBlob = hexStringToBinaryString(kRAW_HEADER); + auto const rawHeaderBlob = hexStringToBinaryString(kRawHeader); auto res = etl::impl::PBLedgerResponseType(); res.set_ledger_header(rawHeaderBlob); diff --git a/tests/common/util/BinaryTestObject.hpp b/tests/common/util/BinaryTestObject.hpp index 44d9dbdfc..266243f9a 100644 --- a/tests/common/util/BinaryTestObject.hpp +++ b/tests/common/util/BinaryTestObject.hpp @@ -13,7 +13,7 @@ namespace util { -static constexpr auto kDEFAULT_TXN_HEX = +static constexpr auto kDefaultTxnHex = "1200192200000008240011CC9B201B001F71D6202A0000000168400000" "000000000C7321ED475D1452031E8F9641AF1631519A58F7B8681E172E" "4838AA0E59408ADA1727DD74406960041F34F10E0CBB39444B4D4E577F" @@ -22,7 +22,7 @@ static constexpr auto kDEFAULT_TXN_HEX = "677265677765697362726F642E636F6D81146203F49C21D5D6E022CB16" "DE3538F248662FC73C"; -static constexpr auto kDEFAULT_TXN_META = +static constexpr auto kDefaultTxnMeta = "201C00000001F8E511005025001F71B3556ED9C9459001E4F4A9121F4E" "07AB6D14898A5BBEF13D85C25D743540DB59F3CF566203F49C21D5D6E0" "22CB16DE3538F248662FC73CFFFFFFFFFFFFFFFFFFFFFFFFE6FAEC5A00" @@ -121,42 +121,39 @@ static constexpr auto kDEFAULT_TXN_META = "066240000002540BE3E081146203F49C21D5D6E022CB16DE3538F24866" "2FC73CE1E1F1031000"; -static constexpr auto kDEFAULT_HASH = +static constexpr auto kDefaultHash = "6C7F69A6D25A13AC4A2E9145999F45D4674F939900017A96885FDC2757E9284E"; -static constexpr auto kDEFAULT_OBJ_KEY = +static constexpr auto kDefaultObjKey = "B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960D"; [[maybe_unused, nodiscard]] std::pair -createTxAndMetaBlobs( - std::string metaStr = kDEFAULT_TXN_META, - std::string txnStr = kDEFAULT_TXN_HEX -); +createTxAndMetaBlobs(std::string metaStr = kDefaultTxnMeta, std::string txnStr = kDefaultTxnHex); [[maybe_unused, nodiscard]] std::pair createTxAndMeta( - std::string hashStr = kDEFAULT_HASH, - std::string metaStr = kDEFAULT_TXN_META, - std::string txnStr = kDEFAULT_TXN_HEX + std::string hashStr = kDefaultHash, + std::string metaStr = kDefaultTxnMeta, + std::string txnStr = kDefaultTxnHex ); [[maybe_unused, nodiscard]] etl::model::Transaction createTransaction( ripple::TxType type, - std::string hashStr = kDEFAULT_HASH, - std::string metaStr = kDEFAULT_TXN_META, - std::string txnStr = kDEFAULT_TXN_HEX + std::string hashStr = kDefaultHash, + std::string metaStr = kDefaultTxnMeta, + std::string txnStr = kDefaultTxnHex ); [[maybe_unused, nodiscard]] etl::model::Object createObject( etl::model::Object::ModType modType = etl::model::Object::ModType::Created, - std::string key = kDEFAULT_OBJ_KEY + std::string key = kDefaultObjKey ); [[maybe_unused, nodiscard]] etl::model::Object createObjectWithBookBase( etl::model::Object::ModType modType = etl::model::Object::ModType::Created, - std::string key = kDEFAULT_OBJ_KEY + std::string key = kDefaultObjKey ); [[maybe_unused, nodiscard]] etl::model::Object diff --git a/tests/common/util/LoggerFixtures.cpp b/tests/common/util/LoggerFixtures.cpp index 1d580f403..047fb1ea7 100644 --- a/tests/common/util/LoggerFixtures.cpp +++ b/tests/common/util/LoggerFixtures.cpp @@ -17,7 +17,7 @@ LoggerFixture::init() { util::LogServiceState::init(false, util::Severity::FTL, {}); - std::ranges::for_each(util::Logger::kCHANNELS, [](std::string_view const channel) { + std::ranges::for_each(util::Logger::kChannels, [](std::string_view const channel) { util::LogService::registerLogger(channel); }); diff --git a/tests/common/util/NameGenerator.hpp b/tests/common/util/NameGenerator.hpp index a3174e814..166b3a931 100644 --- a/tests/common/util/NameGenerator.hpp +++ b/tests/common/util/NameGenerator.hpp @@ -2,6 +2,6 @@ namespace tests::util { -static auto const kNAME_GENERATOR = [](auto const& info) { return info.param.testName; }; +static auto const kNameGenerator = [](auto const& info) { return info.param.testName; }; } // namespace tests::util diff --git a/tests/common/util/TestObject.cpp b/tests/common/util/TestObject.cpp index 388963723..f1df417f3 100644 --- a/tests/common/util/TestObject.cpp +++ b/tests/common/util/TestObject.cpp @@ -40,8 +40,8 @@ #include namespace { -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -ripple::Slice const kSLICE("test", 4); +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +ripple::Slice const kSlice("test", 4); } // namespace ripple::AccountID @@ -80,7 +80,7 @@ createLedgerHeader( // Note: be cautious of using age values close to each other as the underlying NetClock // precision is seconds and the small time difference may lead to comparison bugs auto const now = duration_cast(system_clock::now().time_since_epoch()); - auto const closeTime = (now - seconds{*age}).count() - kRIPPLE_EPOCH_START; + auto const closeTime = (now - seconds{*age}).count() - kRippleEpochStart; ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; } @@ -100,7 +100,7 @@ createLedgerHeaderWithUnixTime( ledgerHeader.hash = ripple::uint256{ledgerHash}; ledgerHeader.seq = seq; - auto const closeTime = closeTimeUnixStamp - seconds{kRIPPLE_EPOCH_START}.count(); + auto const closeTime = closeTimeUnixStamp - seconds{kRippleEpochStart}.count(); ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; return ledgerHeader; @@ -186,7 +186,7 @@ createPaymentTransactionObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) obj.setAccountID(ripple::sfDestination, *account2); obj.setFieldU32(ripple::sfSequence, seq); - obj.setFieldVL(ripple::sfSigningPubKey, kSLICE); + obj.setFieldVL(ripple::sfSigningPubKey, kSlice); return obj; } @@ -720,7 +720,7 @@ createMintNftTxWithMetadata( // required field for ttNFTOKEN_MINT tx.setFieldU32(ripple::sfNFTokenTaxon, nfTokenTaxon); tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta ripple::STObject metaObj(ripple::sfTransactionMetaData); @@ -739,7 +739,7 @@ createMintNftTxWithMetadata( nftArray1.push_back(entry); auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kINDEX1}); + entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kIndex1}); entry2.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); nftArray1.push_back(entry2); @@ -783,7 +783,7 @@ createMintNftTxWithMetadataOfCreatedNode( // required field for ttNFTOKEN_MINT tx.setFieldU32(ripple::sfNFTokenTaxon, nfTokenTaxon); tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); if (uri) tx.setFieldVL(ripple::sfURI, ripple::Slice(uri->data(), uri->size())); @@ -839,7 +839,7 @@ createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID tx.setFieldAmount(ripple::sfFee, amount); tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); if (!uri.empty()) // sfURI should be absent if empty tx.setFieldVL(ripple::sfURI, uri); @@ -897,7 +897,7 @@ createNftBurnTxWithMetadataOfDeletedNode(std::string_view accountId, std::string tx.setFieldAmount(ripple::sfFee, amount); tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta ripple::STObject metaObj(ripple::sfTransactionMetaData); @@ -942,7 +942,7 @@ createNftBurnTxWithMetadataOfModifiedNode(std::string_view accountId, std::strin tx.setFieldAmount(ripple::sfFee, amount); tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta ripple::STObject metaObj(ripple::sfTransactionMetaData); @@ -989,7 +989,7 @@ createAcceptNftBuyerOfferTxWithMetadata( tx.setFieldAmount(ripple::sfFee, amount); tx.setFieldU32(ripple::sfSequence, seq); tx.setFieldH256(ripple::sfNFTokenBuyOffer, ripple::uint256{offerId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta // create deletedNode with ltNFTOKEN_OFFER @@ -1037,7 +1037,7 @@ createAcceptNftSellerOfferTxWithMetadata( tx.setFieldAmount(ripple::sfFee, amount); tx.setFieldU32(ripple::sfSequence, seq); tx.setFieldH256(ripple::sfNFTokenSellOffer, ripple::uint256{offerId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta // create deletedNode with ltNFTOKEN_OFFER @@ -1085,7 +1085,7 @@ createAcceptNftSellerOfferTxWithMetadata( nftArray1.push_back(entry); auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kINDEX1}); + entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kIndex1}); nftArray1.push_back(entry2); finalFields.setFieldArray(ripple::sfNFTokens, nftArray1); @@ -1133,7 +1133,7 @@ createCancelNftOffersTxWithMetadata( return ripple::uint256{nftId.c_str()}; }); tx.setFieldV256(ripple::sfNFTokenOffers, offers); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta // create deletedNode with ltNFTOKEN_OFFER @@ -1182,7 +1182,7 @@ createCreateNftOfferTxWithMetadata( tx.setFieldAmount(ripple::sfAmount, price); tx.setFieldU32(ripple::sfSequence, seq); tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); // meta // create createdNode with LedgerIndex @@ -1227,7 +1227,7 @@ createOracleSetTxWithMetadata( tx.setFieldU32(ripple::sfLastUpdateTime, lastUpdateTime); tx.setFieldU32(ripple::sfOracleDocumentID, docId); tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); tx.setFieldArray(ripple::sfPriceDataSeries, priceDataSeries); // meta @@ -1568,7 +1568,7 @@ createMPTIssuanceCreateTx(std::string_view accountId, uint32_t fee, uint32_t seq tx.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); tx.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); return tx; } @@ -1626,7 +1626,7 @@ createMPTokenAuthorizeTx( tx[ripple::sfMPTokenIssuanceID] = mptIssuanceID; tx.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldVL(ripple::sfSigningPubKey, kSlice); if (holder) tx.setAccountID(ripple::sfHolder, getAccountIdWithString(*holder)); diff --git a/tests/common/util/config/FakeConfigData.hpp b/tests/common/util/config/FakeConfigData.hpp index 84b0798d5..4af0b1e62 100644 --- a/tests/common/util/config/FakeConfigData.hpp +++ b/tests/common/util/config/FakeConfigData.hpp @@ -85,7 +85,7 @@ generateConfig() */ /* Used to test overwriting default values in ClioConfigDefinition Above */ -static constexpr auto kJSON_DATA = R"JSON({ +static constexpr auto kJsonData = R"JSON({ "header": { "text1": "value", "port": 321, @@ -177,7 +177,7 @@ format; */ // Invalid Json key/values -static constexpr auto kINVALID_JSON_DATA = R"JSON({ +static constexpr auto kInvalidJsonData = R"JSON({ "header": { "port": "999", "admin": "true" diff --git a/tests/integration/TestGlobals.cpp b/tests/integration/TestGlobals.cpp index 0fcd7ad0d..1f43d7225 100644 --- a/tests/integration/TestGlobals.cpp +++ b/tests/integration/TestGlobals.cpp @@ -9,8 +9,8 @@ TestGlobals& TestGlobals::instance() { - static TestGlobals kINST; - return kINST; + static TestGlobals kInst; + return kInst; } void diff --git a/tests/integration/data/BackendFactoryTests.cpp b/tests/integration/data/BackendFactoryTests.cpp index 1471f8806..6dd6cc875 100644 --- a/tests/integration/data/BackendFactoryTests.cpp +++ b/tests/integration/data/BackendFactoryTests.cpp @@ -24,8 +24,8 @@ using namespace util::config; struct BackendCassandraFactoryTest : SyncAsioContextTest, util::prometheus::WithPrometheus { - static constexpr auto kKEYSPACE = "factory_test"; - static constexpr auto kPROVIDER = "cassandra"; + static constexpr auto kKeyspace = "factory_test"; + static constexpr auto kProvider = "cassandra"; protected: ClioConfigDefinition cfg_{ @@ -34,8 +34,8 @@ protected: ConfigValue{ConfigType::String}.defaultValue(TestGlobals::instance().backendHost)}, {"database.cassandra.secure_connect_bundle", ConfigValue{ConfigType::String}.optional()}, {"database.cassandra.port", ConfigValue{ConfigType::Integer}.optional()}, - {"database.cassandra.keyspace", ConfigValue{ConfigType::String}.defaultValue(kKEYSPACE)}, - {"database.cassandra.provider", ConfigValue{ConfigType::String}.defaultValue(kPROVIDER)}, + {"database.cassandra.keyspace", ConfigValue{ConfigType::String}.defaultValue(kKeyspace)}, + {"database.cassandra.provider", ConfigValue{ConfigType::String}.defaultValue(kProvider)}, {"database.cassandra.replication_factor", ConfigValue{ConfigType::Integer}.defaultValue(1)}, {"database.cassandra.table_prefix", ConfigValue{ConfigType::String}.optional()}, {"database.cassandra.max_write_requests_outstanding", @@ -81,7 +81,7 @@ public: // drop the keyspace for next test data::cassandra::Handle const handle{TestGlobals::instance().backendHost}; EXPECT_TRUE(handle.connect()); - EXPECT_TRUE(handle.execute("DROP KEYSPACE IF EXISTS " + std::string{kKEYSPACE})); + EXPECT_TRUE(handle.execute("DROP KEYSPACE IF EXISTS " + std::string{kKeyspace})); } }; @@ -122,12 +122,12 @@ TEST_F(BackendCassandraFactoryTestWithDB, CreateCassandraBackend) EXPECT_TRUE(handle.connect()); EXPECT_TRUE(handle.execute( fmt::format( - "INSERT INTO {}.ledger_range (is_latest, sequence) VALUES (False, 100)", kKEYSPACE + "INSERT INTO {}.ledger_range (is_latest, sequence) VALUES (False, 100)", kKeyspace ) )); EXPECT_TRUE(handle.execute( fmt::format( - "INSERT INTO {}.ledger_range (is_latest, sequence) VALUES (True, 500)", kKEYSPACE + "INSERT INTO {}.ledger_range (is_latest, sequence) VALUES (True, 500)", kKeyspace ) )); } diff --git a/tests/integration/data/cassandra/BackendTests.cpp b/tests/integration/data/cassandra/BackendTests.cpp index 449572a41..f05b03b01 100644 --- a/tests/integration/data/cassandra/BackendTests.cpp +++ b/tests/integration/data/cassandra/BackendTests.cpp @@ -66,17 +66,17 @@ using namespace data::cassandra; class BackendCassandraTestBase : public SyncAsioContextTest, public WithPrometheus { protected: - static constexpr auto kCASSANDRA = "cassandra"; + static constexpr auto kCassandra = "cassandra"; ClioConfigDefinition cfg_{ - {"database.type", ConfigValue{ConfigType::String}.defaultValue(kCASSANDRA)}, + {"database.type", ConfigValue{ConfigType::String}.defaultValue(kCassandra)}, {"database.cassandra.contact_points", ConfigValue{ConfigType::String}.defaultValue(TestGlobals::instance().backendHost)}, {"database.cassandra.secure_connect_bundle", ConfigValue{ConfigType::String}.optional()}, {"database.cassandra.port", ConfigValue{ConfigType::Integer}.optional()}, {"database.cassandra.keyspace", ConfigValue{ConfigType::String}.defaultValue(TestGlobals::instance().backendKeyspace)}, - {"database.cassandra.provider", ConfigValue{ConfigType::String}.defaultValue(kCASSANDRA)}, + {"database.cassandra.provider", ConfigValue{ConfigType::String}.defaultValue(kCassandra)}, {"database.cassandra.replication_factor", ConfigValue{ConfigType::Integer}.defaultValue(1)}, {"database.cassandra.table_prefix", ConfigValue{ConfigType::String}.optional()}, {"database.cassandra.max_write_requests_outstanding", @@ -102,7 +102,7 @@ protected: {"read_only", ConfigValue{ConfigType::Boolean}.defaultValue(false)} }; - static constexpr auto kRAWHEADER = + static constexpr auto kRawheader = "03C3141A01633CD656F91B4EBB5EB89B791BD34DBC8A04BB6F407C5335BC54351E" "DD733898497E809E04074D14D271E4832D7888754F9230800761563A292FA2315A" "6DB6FE30CC5909B285080FCD6773CC883F9FE0EE4D439340AC592AADB973ED3CF5" @@ -153,7 +153,7 @@ TEST_F(BackendCassandraTest, Basic) backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfo.seq, uint256ToString(data::kLAST_KEY) + uint256ToString(data::kFirstKey), lgrInfo.seq, uint256ToString(data::kLastKey) ); ASSERT_TRUE(backend_->finishWrites(lgrInfo.seq)); { @@ -451,10 +451,10 @@ TEST_F(BackendCassandraTest, Basic) std::string{accountIndexBlob}, lgrInfoNext.seq, std::string{accountBlob} ); backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfoNext.seq, std::string{accountIndexBlob} + uint256ToString(data::kFirstKey), lgrInfoNext.seq, std::string{accountIndexBlob} ); backend_->writeSuccessor( - std::string{accountIndexBlob}, lgrInfoNext.seq, uint256ToString(data::kLAST_KEY) + std::string{accountIndexBlob}, lgrInfoNext.seq, uint256ToString(data::kLastKey) ); ASSERT_TRUE(backend_->finishWrites(lgrInfoNext.seq)); @@ -575,7 +575,7 @@ TEST_F(BackendCassandraTest, Basic) std::string{accountIndexBlob}, lgrInfoNext.seq, std::string{} ); backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfoNext.seq, uint256ToString(data::kLAST_KEY) + uint256ToString(data::kFirstKey), lgrInfoNext.seq, uint256ToString(data::kLastKey) ); ASSERT_TRUE(backend_->finishWrites(lgrInfoNext.seq)); @@ -710,9 +710,7 @@ TEST_F(BackendCassandraTest, Basic) ); } else { backend_->writeSuccessor( - std::string{objs[i].first}, - lgrInfo.seq, - uint256ToString(data::kLAST_KEY) + std::string{objs[i].first}, lgrInfo.seq, uint256ToString(data::kLastKey) ); } } @@ -724,7 +722,7 @@ TEST_F(BackendCassandraTest, Basic) ); } else { backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfo.seq, std::string{objs[0].first} + uint256ToString(data::kFirstKey), lgrInfo.seq, std::string{objs[0].first} ); } } @@ -975,7 +973,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) std::string const accountIndexHex = "E0311EB450B6177F969B94DBDDA83E99B7A0576ACD9079573876F16C0C004F06"; - std::string rawHeaderBlob = hexStringToBinaryString(kRAWHEADER); + std::string rawHeaderBlob = hexStringToBinaryString(kRawheader); std::string accountBlob = hexStringToBinaryString(accountHex); std::string const accountIndexBlob = hexStringToBinaryString(accountIndexHex); ripple::LedgerHeader const lgrInfo = @@ -984,7 +982,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) backend_->startWrites(); backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfo.seq, uint256ToString(data::kLAST_KEY) + uint256ToString(data::kFirstKey), lgrInfo.seq, uint256ToString(data::kLastKey) ); ASSERT_TRUE(backend_->finishWrites(lgrInfo.seq)); { @@ -1064,10 +1062,10 @@ TEST_F(BackendCassandraTest, CacheIntegration) {{.key = *key, .blob = {accountBlob.begin(), accountBlob.end()}}}, lgrInfoNext.seq ); backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfoNext.seq, std::string{accountIndexBlob} + uint256ToString(data::kFirstKey), lgrInfoNext.seq, std::string{accountIndexBlob} ); backend_->writeSuccessor( - std::string{accountIndexBlob}, lgrInfoNext.seq, uint256ToString(data::kLAST_KEY) + std::string{accountIndexBlob}, lgrInfoNext.seq, uint256ToString(data::kLastKey) ); ASSERT_TRUE(backend_->finishWrites(lgrInfoNext.seq)); @@ -1164,7 +1162,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) std::string{accountIndexBlob}, lgrInfoNext.seq, std::string{} ); backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfoNext.seq, uint256ToString(data::kLAST_KEY) + uint256ToString(data::kFirstKey), lgrInfoNext.seq, uint256ToString(data::kLastKey) ); ASSERT_TRUE(backend_->finishWrites(lgrInfoNext.seq)); @@ -1247,9 +1245,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) ); } else { backend_->writeSuccessor( - std::string{objs[i].first}, - lgrInfo.seq, - uint256ToString(data::kLAST_KEY) + std::string{objs[i].first}, lgrInfo.seq, uint256ToString(data::kLastKey) ); } } @@ -1261,7 +1257,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) ); } else { backend_->writeSuccessor( - uint256ToString(data::kFIRST_KEY), lgrInfo.seq, std::string{objs[0].first} + uint256ToString(data::kFirstKey), lgrInfo.seq, std::string{objs[0].first} ); } } @@ -1423,7 +1419,7 @@ public: TEST_F(CacheBackendCassandraTest, CacheFetchLedgerBySeq) { runSpawn([&](boost::asio::yield_context yield) { - auto rawHeaderBlob = hexStringToBinaryString(kRAWHEADER); + auto rawHeaderBlob = hexStringToBinaryString(kRawheader); ripple::LedgerHeader const lgrInfo = util::deserializeHeader(ripple::makeSlice(rawHeaderBlob)); @@ -1471,31 +1467,31 @@ struct BackendCassandraNodeMessageTest : BackendCassandraTest { TEST_F(BackendCassandraNodeMessageTest, UpdateFetch) { - static boost::uuids::uuid const kUUID = generateUuid(); - static std::string const kMESSAGE = "some message"; + static boost::uuids::uuid const kUuid = generateUuid(); + static std::string const kMessage = "some message"; - EXPECT_NO_THROW({ backend_->writeNodeMessage(kUUID, kMESSAGE); }); + EXPECT_NO_THROW({ backend_->writeNodeMessage(kUuid, kMessage); }); runSpawn([&](boost::asio::yield_context yield) { auto const readResult = backend_->fetchClioNodesData(yield); ASSERT_TRUE(readResult) << readResult.error(); ASSERT_EQ(readResult->size(), 1); auto const& [uuid, message] = (*readResult)[0]; - EXPECT_EQ(uuid, kUUID); - EXPECT_EQ(message, kMESSAGE); + EXPECT_EQ(uuid, kUuid); + EXPECT_EQ(message, kMessage); }); } TEST_F(BackendCassandraNodeMessageTest, UpdateFetchMultipleMessages) { - std::unordered_map kDATA = { + std::unordered_map kData = { {generateUuid(), std::string{"some message"}}, {generateUuid(), std::string{"other message"}}, {generateUuid(), std::string{"message 3"}} }; EXPECT_NO_THROW({ - for (auto const& [uuid, message] : kDATA) { + for (auto const& [uuid, message] : kData) { backend_->writeNodeMessage(uuid, message); } }); @@ -1503,12 +1499,12 @@ TEST_F(BackendCassandraNodeMessageTest, UpdateFetchMultipleMessages) runSpawn([&](boost::asio::yield_context yield) { auto const readResult = backend_->fetchClioNodesData(yield); ASSERT_TRUE(readResult) << readResult.error(); - ASSERT_EQ(readResult->size(), kDATA.size()); + ASSERT_EQ(readResult->size(), kData.size()); for (size_t i = 0; i < readResult->size(); ++i) { auto const& [uuid, message] = (*readResult)[i]; - auto const it = kDATA.find(uuid); - ASSERT_NE(it, kDATA.end()) << uuid << " not found"; + auto const it = kData.find(uuid); + ASSERT_NE(it, kData.end()) << uuid << " not found"; EXPECT_EQ(it->second, message); } }); @@ -1531,13 +1527,13 @@ TEST_F(BackendCassandraNodeMessageTest, UpdatingMessageKeepsItAlive) #if defined(__APPLE__) GTEST_SKIP() << "Skipping test on Apple platform due to slow DB"; #else - static boost::uuids::uuid const kUUID = generateUuid(); - static std::string const kUPDATED_MESSAGE = "updated message"; + static boost::uuids::uuid const kUuid = generateUuid(); + static std::string const kUpdatedMessage = "updated message"; - EXPECT_NO_THROW({ backend_->writeNodeMessage(kUUID, "some message"); }); + EXPECT_NO_THROW({ backend_->writeNodeMessage(kUuid, "some message"); }); std::this_thread::sleep_for(std::chrono::milliseconds{1000}); - EXPECT_NO_THROW({ backend_->writeNodeMessage(kUUID, kUPDATED_MESSAGE); }); + EXPECT_NO_THROW({ backend_->writeNodeMessage(kUuid, kUpdatedMessage); }); std::this_thread::sleep_for(std::chrono::milliseconds{1005}); runSpawn([&](boost::asio::yield_context yield) { @@ -1545,8 +1541,8 @@ TEST_F(BackendCassandraNodeMessageTest, UpdatingMessageKeepsItAlive) ASSERT_TRUE(readResult) << readResult.error(); ASSERT_EQ(readResult->size(), 1); auto const& [uuid, message] = (*readResult)[0]; - EXPECT_EQ(uuid, kUUID); - EXPECT_EQ(message, kUPDATED_MESSAGE); + EXPECT_EQ(uuid, kUuid); + EXPECT_EQ(message, kUpdatedMessage); }); #endif } diff --git a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp index ecf46fb73..e835a43c9 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp +++ b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp @@ -81,15 +81,15 @@ class MigrationCassandraSimpleTest : public WithPrometheus { } protected: - static constexpr auto kCASSANDRA = "cassandra"; + static constexpr auto kCassandra = "cassandra"; ClioConfigDefinition cfg_{ - {{"database.type", ConfigValue{ConfigType::String}.defaultValue(kCASSANDRA)}, + {{"database.type", ConfigValue{ConfigType::String}.defaultValue(kCassandra)}, {"database.cassandra.contact_points", ConfigValue{ConfigType::String}.defaultValue(TestGlobals::instance().backendHost)}, {"database.cassandra.keyspace", ConfigValue{ConfigType::String}.defaultValue(TestGlobals::instance().backendKeyspace)}, - {"database.cassandra.provider", ConfigValue{ConfigType::String}.defaultValue(kCASSANDRA)}, + {"database.cassandra.provider", ConfigValue{ConfigType::String}.defaultValue(kCassandra)}, {"database.cassandra.replication_factor", ConfigValue{ConfigType::Integer}.defaultValue(1)}, {"database.cassandra.replication_factor", @@ -214,14 +214,14 @@ class MigrationCassandraManagerTxTableTest : public MigrationCassandraSimpleTest TEST_F(MigrationCassandraManagerTxTableTest, MigrateExampleTransactionsMigrator) { - constexpr auto kTRANSACTIONS_MIGRATOR_NAME = "ExampleTransactionsMigrator"; + constexpr auto kTransactionsMigratorName = "ExampleTransactionsMigrator"; EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kTRANSACTIONS_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kTransactionsMigratorName), MigratorStatus::Status::NotMigrated ); ExampleTransactionsMigrator::count = 0; - testMigrationManager_->runMigration(kTRANSACTIONS_MIGRATOR_NAME); + testMigrationManager_->runMigration(kTransactionsMigratorName); EXPECT_EQ(ExampleTransactionsMigrator::count, gTransactionsRawData.size()); auto const newTableSize = data::synchronous([&](auto ctx) { @@ -260,7 +260,7 @@ TEST_F(MigrationCassandraManagerTxTableTest, MigrateExampleTransactionsMigrator) EXPECT_EQ(txType.value(), "AMMCreate"); EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kTRANSACTIONS_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kTransactionsMigratorName), MigratorStatus::Status::Migrated ); } @@ -281,19 +281,19 @@ class MigrationCassandraManagerObjectsTableTest : public MigrationCassandraSimpl TEST_F(MigrationCassandraManagerObjectsTableTest, MigrateExampleObjectsMigrator) { - constexpr auto kOBJECTS_MIGRATOR_NAME = "ExampleObjectsMigrator"; + constexpr auto kObjectsMigratorName = "ExampleObjectsMigrator"; EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kOBJECTS_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kObjectsMigratorName), MigratorStatus::Status::NotMigrated ); - testMigrationManager_->runMigration(kOBJECTS_MIGRATOR_NAME); + testMigrationManager_->runMigration(kObjectsMigratorName); EXPECT_EQ(ExampleObjectsMigrator::count, gObjectsRawData.size()); EXPECT_EQ(ExampleObjectsMigrator::accountCount, 37); EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kOBJECTS_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kObjectsMigratorName), MigratorStatus::Status::Migrated ); } @@ -315,15 +315,15 @@ class MigrationCassandraManagerLedgerTableTest : public MigrationCassandraSimple TEST_F(MigrationCassandraManagerLedgerTableTest, MigrateExampleLedgerMigrator) { - constexpr auto kHEADER_MIGRATOR_NAME = "ExampleLedgerMigrator"; + constexpr auto kHeaderMigratorName = "ExampleLedgerMigrator"; EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kHEADER_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kHeaderMigratorName), MigratorStatus::Status::NotMigrated ); - testMigrationManager_->runMigration(kHEADER_MIGRATOR_NAME); + testMigrationManager_->runMigration(kHeaderMigratorName); EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kHEADER_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kHeaderMigratorName), MigratorStatus::Status::Migrated ); @@ -357,9 +357,9 @@ class MigrationCassandraManagerDropTableTest : public MigrationCassandraSimpleTe TEST_F(MigrationCassandraManagerDropTableTest, MigrateDropTableMigrator) { - constexpr auto kDROP_TABLE_MIGRATOR_NAME = "ExampleDropTableMigrator"; + constexpr auto kDropTableMigratorName = "ExampleDropTableMigrator"; EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kDROP_TABLE_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kDropTableMigratorName), MigratorStatus::Status::NotMigrated ); @@ -367,9 +367,9 @@ TEST_F(MigrationCassandraManagerDropTableTest, MigrateDropTableMigrator) data::synchronous([&](auto ctx) { return testMigrationBackend_->fetchDiffTableSize(ctx); }); EXPECT_EQ(beforeDropSize, 0); - testMigrationManager_->runMigration(kDROP_TABLE_MIGRATOR_NAME); + testMigrationManager_->runMigration(kDropTableMigratorName); EXPECT_EQ( - testMigrationManager_->getMigratorStatusByName(kDROP_TABLE_MIGRATOR_NAME), + testMigrationManager_->getMigratorStatusByName(kDropTableMigratorName), MigratorStatus::Status::Migrated ); diff --git a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp index 3f353846c..507309e99 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp +++ b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp @@ -57,7 +57,7 @@ public: void writeTxIndexExample(std::string const& hash, std::string const& txType) { - static auto kINSERT_TX_INDEX_EXAMPLE = [this]() { + static auto kInsertTxIndexExample = [this]() { return handle_.prepare( fmt::format( R"( @@ -69,7 +69,7 @@ public: ) ); }(); - executor_.writeSync(kINSERT_TX_INDEX_EXAMPLE.bind(hash, data::cassandra::Text(txType))); + executor_.writeSync(kInsertTxIndexExample.bind(hash, data::cassandra::Text(txType))); } /** @@ -83,7 +83,7 @@ public: std::optional fetchTxTypeViaID(std::string const& hash, boost::asio::yield_context ctx) { - static auto kFETCH_TX_TYPE = [this]() { + static auto kFetchTxType = [this]() { return handle_.prepare( fmt::format( R"( @@ -93,7 +93,7 @@ public: ) ); }(); - auto const res = executor_.read(ctx, kFETCH_TX_TYPE.bind(hash)); + auto const res = executor_.read(ctx, kFetchTxType.bind(hash)); if (not res) { return std::nullopt; } @@ -119,7 +119,7 @@ public: std::optional fetchTxIndexTableSize(boost::asio::yield_context ctx) { - static auto kINSERT_TX_INDEX_EXAMPLE = [this]() { + static auto kInsertTxIndexExample = [this]() { return handle_.prepare( fmt::format( R"( @@ -132,7 +132,7 @@ public: // This function will be called after table being dropped, catch the exception try { - auto const res = executor_.read(ctx, kINSERT_TX_INDEX_EXAMPLE); + auto const res = executor_.read(ctx, kInsertTxIndexExample); if (not res) { return std::nullopt; } @@ -161,7 +161,7 @@ public: void writeLedgerAccountHash(std::uint64_t sequence, std::string const& accountHash) { - static auto kINSERT_LEDGER_EXAMPLE = [this]() { + static auto kInsertLedgerExample = [this]() { return handle_.prepare( fmt::format( R"( @@ -173,7 +173,7 @@ public: ) ); }(); - executor_.writeSync(kINSERT_LEDGER_EXAMPLE.bind(sequence, accountHash)); + executor_.writeSync(kInsertLedgerExample.bind(sequence, accountHash)); } /** @@ -187,7 +187,7 @@ public: std::optional fetchAccountHashViaSequence(std::uint64_t sequence, boost::asio::yield_context ctx) { - static auto kFETCH_ACCOUNT_HASH = [this]() { + static auto kFetchAccountHash = [this]() { return handle_.prepare( fmt::format( R"( @@ -197,7 +197,7 @@ public: ) ); }(); - auto const res = executor_.read(ctx, kFETCH_ACCOUNT_HASH.bind(sequence)); + auto const res = executor_.read(ctx, kFetchAccountHash.bind(sequence)); if (not res) { return std::nullopt; } @@ -222,7 +222,7 @@ public: std::optional fetchLedgerTableSize(boost::asio::yield_context ctx) { - static auto kINSERT_LEDGER_EXAMPLE = [this]() { + static auto kInsertLedgerExample = [this]() { return handle_.prepare( fmt::format( R"( @@ -235,7 +235,7 @@ public: // This function will be called after table being dropped, catch the exception try { - auto const res = executor_.read(ctx, kINSERT_LEDGER_EXAMPLE); + auto const res = executor_.read(ctx, kInsertLedgerExample); if (not res) { return std::nullopt; } @@ -281,7 +281,7 @@ public: std::optional fetchDiffTableSize(boost::asio::yield_context ctx) { - static auto kCOUNT_DIFF = [this]() { + static auto kCountDiff = [this]() { return handle_.prepare( fmt::format( R"( @@ -294,7 +294,7 @@ public: // This function will be called after table being dropped, catch the exception try { - auto const res = executor_.read(ctx, kCOUNT_DIFF); + auto const res = executor_.read(ctx, kCountDiff); if (not res) { return std::nullopt; } diff --git a/tests/integration/migration/cassandra/ExampleDropTableMigrator.hpp b/tests/integration/migration/cassandra/ExampleDropTableMigrator.hpp index 671a5fd77..0bc550daf 100644 --- a/tests/integration/migration/cassandra/ExampleDropTableMigrator.hpp +++ b/tests/integration/migration/cassandra/ExampleDropTableMigrator.hpp @@ -12,8 +12,8 @@ struct ExampleDropTableMigrator { using Backend = CassandraMigrationTestBackend; - static constexpr char const* kNAME = "ExampleDropTableMigrator"; - static constexpr char const* kDESCRIPTION = "The migrator for dropping the table"; + static constexpr char const* kName = "ExampleDropTableMigrator"; + static constexpr char const* kDescription = "The migrator for dropping the table"; static void runMigration(std::shared_ptr const& backend, util::config::ObjectView const& config); diff --git a/tests/integration/migration/cassandra/ExampleLedgerMigrator.hpp b/tests/integration/migration/cassandra/ExampleLedgerMigrator.hpp index 5f736ce94..3651bed1d 100644 --- a/tests/integration/migration/cassandra/ExampleLedgerMigrator.hpp +++ b/tests/integration/migration/cassandra/ExampleLedgerMigrator.hpp @@ -12,8 +12,8 @@ * key of ledgers table, we can just fetch the data via ledger sequence without full table scan. */ struct ExampleLedgerMigrator { - static constexpr char const* kNAME = "ExampleLedgerMigrator"; - static constexpr char const* kDESCRIPTION = "The migrator for ledgers table"; + static constexpr char const* kName = "ExampleLedgerMigrator"; + static constexpr char const* kDescription = "The migrator for ledgers table"; using Backend = CassandraMigrationTestBackend; diff --git a/tests/integration/migration/cassandra/ExampleObjectsMigrator.hpp b/tests/integration/migration/cassandra/ExampleObjectsMigrator.hpp index f7e280d50..1232ec12b 100644 --- a/tests/integration/migration/cassandra/ExampleObjectsMigrator.hpp +++ b/tests/integration/migration/cassandra/ExampleObjectsMigrator.hpp @@ -16,8 +16,8 @@ struct ExampleObjectsMigrator { using Backend = CassandraMigrationTestBackend; - static constexpr char const* kNAME = "ExampleObjectsMigrator"; - static constexpr char const* kDESCRIPTION = "The migrator for objects table"; + static constexpr char const* kName = "ExampleObjectsMigrator"; + static constexpr char const* kDescription = "The migrator for objects table"; static std::atomic_int64_t count; static std::atomic_int64_t accountCount; diff --git a/tests/integration/migration/cassandra/ExampleTransactionsMigrator.hpp b/tests/integration/migration/cassandra/ExampleTransactionsMigrator.hpp index 999b67cd8..a627e0d6d 100644 --- a/tests/integration/migration/cassandra/ExampleTransactionsMigrator.hpp +++ b/tests/integration/migration/cassandra/ExampleTransactionsMigrator.hpp @@ -12,8 +12,8 @@ * hash to transaction type string. */ struct ExampleTransactionsMigrator { - static constexpr char const* kNAME = "ExampleTransactionsMigrator"; - static constexpr char const* kDESCRIPTION = "The migrator for transactions table"; + static constexpr char const* kName = "ExampleTransactionsMigrator"; + static constexpr char const* kDescription = "The migrator for transactions table"; using Backend = CassandraMigrationTestBackend; static std::uint64_t count; diff --git a/tests/unit/JsonUtilTests.cpp b/tests/unit/JsonUtilTests.cpp index 956460129..b809e3fd9 100644 --- a/tests/unit/JsonUtilTests.cpp +++ b/tests/unit/JsonUtilTests.cpp @@ -179,7 +179,7 @@ INSTANTIATE_TEST_CASE_P( .expectedResult = std::unexpected{"'validated' ledger index is requested"} } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(GetLedgerIndexParameterTest, getLedgerIndexParams) diff --git a/tests/unit/app/CliArgsTests.cpp b/tests/unit/app/CliArgsTests.cpp index 0d46396a8..611127bd4 100644 --- a/tests/unit/app/CliArgsTests.cpp +++ b/tests/unit/app/CliArgsTests.cpp @@ -30,7 +30,7 @@ TEST_F(CliArgsTests, Parse_NoArgs) int const returnCode = 123; EXPECT_CALL(onRunMock, Call).WillOnce([](CliArgs::Action::Run const& run) { - EXPECT_EQ(run.configPath, CliArgs::kDEFAULT_CONFIG_PATH); + EXPECT_EQ(run.configPath, CliArgs::kDefaultConfigPath); EXPECT_FALSE(run.useNgWebServer); return returnCode; }); @@ -53,7 +53,7 @@ TEST_F(CliArgsTests, Parse_NgWebServer) int const returnCode = 123; EXPECT_CALL(onRunMock, Call).WillOnce([](CliArgs::Action::Run const& run) { - EXPECT_EQ(run.configPath, CliArgs::kDEFAULT_CONFIG_PATH); + EXPECT_EQ(run.configPath, CliArgs::kDefaultConfigPath); EXPECT_TRUE(run.useNgWebServer); return returnCode; }); diff --git a/tests/unit/app/VerifyConfigTests.cpp b/tests/unit/app/VerifyConfigTests.cpp index 6ce55c7bc..638f0278c 100644 --- a/tests/unit/app/VerifyConfigTests.cpp +++ b/tests/unit/app/VerifyConfigTests.cpp @@ -9,22 +9,22 @@ using namespace util::config; TEST(VerifyConfigTest, InvalidConfig) { - auto const tmpConfigFile = TmpFile(kJSON_DATA); + auto const tmpConfigFile = TmpFile(kJsonData); - // false because json data(kJSON_DATA) is not compatible with current configDefinition + // false because json data(kJsonData) is not compatible with current configDefinition EXPECT_FALSE(parseConfig(tmpConfigFile.path)); } TEST(VerifyConfigTest, ValidConfig) { // used to Verify Config test - static constexpr auto kVALID_JSON_DATA = R"JSON({ + static constexpr auto kValidJsonData = R"JSON({ "server": { "ip": "0.0.0.0", "port": 51233 } })JSON"; - auto const tmpConfigFile = TmpFile(kVALID_JSON_DATA); + auto const tmpConfigFile = TmpFile(kValidJsonData); // current example config should always be compatible with configDefinition EXPECT_TRUE(parseConfig(tmpConfigFile.path)); @@ -38,13 +38,13 @@ TEST(VerifyConfigTest, ConfigFileNotExist) TEST(VerifyConfigTest, InvalidJsonFile) { // invalid json because extra "," after 51233 - static constexpr auto kINVALID_JSON = R"JSON({ + static constexpr auto kInvalidJson = R"JSON({ "server": { "ip": "0.0.0.0", "port": 51233, } })JSON"; - auto const tmpConfigFile = TmpFile(kINVALID_JSON); + auto const tmpConfigFile = TmpFile(kInvalidJson); EXPECT_FALSE(parseConfig(tmpConfigFile.path)); } diff --git a/tests/unit/cluster/ClioNodeTests.cpp b/tests/unit/cluster/ClioNodeTests.cpp index c380c2dff..ea4e23c61 100644 --- a/tests/unit/cluster/ClioNodeTests.cpp +++ b/tests/unit/cluster/ClioNodeTests.cpp @@ -26,7 +26,7 @@ struct ClioNodeTest : testing::Test { std::string const updateTimeStr = "2015-05-15T12:00:00Z"; std::chrono::system_clock::time_point const updateTime = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *util::systemTpFromUtcStr(updateTimeStr, ClioNode::kTIME_FORMAT); + *util::systemTpFromUtcStr(updateTimeStr, ClioNode::kTimeFormat); }; TEST_F(ClioNodeTest, Serialization) @@ -205,7 +205,7 @@ INSTANTIATE_TEST_SUITE_P( .role = ClioNode::DbRole::FallbackRecovery } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(ClioNodeDbRoleTest, Serialization) @@ -317,7 +317,7 @@ INSTANTIATE_TEST_SUITE_P( .expectedRole = ClioNode::DbRole::FallbackRecovery } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(ClioNodeFromTest, FromWriterState) diff --git a/tests/unit/cluster/ClusterCommunicationServiceTests.cpp b/tests/unit/cluster/ClusterCommunicationServiceTests.cpp index b5e263f3b..e49d47ab1 100644 --- a/tests/unit/cluster/ClusterCommunicationServiceTests.cpp +++ b/tests/unit/cluster/ClusterCommunicationServiceTests.cpp @@ -38,7 +38,7 @@ struct ClusterCommunicationServiceTest : util::prometheus::WithPrometheus, MockB std::unique_ptr cacheLoadingState = std::make_unique(); - static constexpr std::chrono::milliseconds kSHORT_INTERVAL{1}; + static constexpr std::chrono::milliseconds kShortInterval{1}; static boost::uuids::uuid makeUuid(uint8_t value) @@ -118,8 +118,8 @@ TEST_F(ClusterCommunicationServiceTest, BackendReadsAndWritesData) backend_, std::move(writerState), std::move(cacheLoadingState), - kSHORT_INTERVAL, - kSHORT_INTERVAL + kShortInterval, + kShortInterval }; service.run(); @@ -163,8 +163,8 @@ TEST_F(ClusterCommunicationServiceTest, MetricsGetsNewStateFromBackend) backend_, std::move(writerState), std::move(cacheLoadingState), - kSHORT_INTERVAL, - kSHORT_INTERVAL + kShortInterval, + kShortInterval }; service.run(); @@ -212,8 +212,8 @@ TEST_F(ClusterCommunicationServiceTest, WriterDeciderCallsWriterStateMethodsAcco backend_, std::move(writerState), std::move(cacheLoadingState), - kSHORT_INTERVAL, - kSHORT_INTERVAL + kShortInterval, + kShortInterval }; service.run(); @@ -246,8 +246,8 @@ TEST_F(ClusterCommunicationServiceTest, StopHaltsBackendOperations) backend_, std::move(writerState), std::move(cacheLoadingState), - kSHORT_INTERVAL, - kSHORT_INTERVAL + kShortInterval, + kShortInterval }; service.run(); @@ -284,7 +284,7 @@ INSTANTIATE_TEST_SUITE_P( .limitLoadInCluster = false } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(ClusterCommunicationServiceMakeTest, LoadingAllowedMatchesConfig) diff --git a/tests/unit/cluster/RepeatedTaskTests.cpp b/tests/unit/cluster/RepeatedTaskTests.cpp index 4fb4929e5..823b256c9 100644 --- a/tests/unit/cluster/RepeatedTaskTests.cpp +++ b/tests/unit/cluster/RepeatedTaskTests.cpp @@ -16,7 +16,7 @@ using namespace cluster::impl; using namespace testing; struct RepeatedTaskTest : AsyncAsioContextTest { - static constexpr auto kTIMEOUT = std::chrono::seconds{5}; + static constexpr auto kTimeout = std::chrono::seconds{5}; }; template @@ -57,7 +57,7 @@ TYPED_TEST(RepeatedTaskTypedTest, CallsFunctionRepeatedly) task.run(this->mockFn.AsStdFunction()); - EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTIMEOUT)); + EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTimeout)); task.stop(); } @@ -84,7 +84,7 @@ TYPED_TEST(RepeatedTaskTypedTest, MultipleStops) task.run(this->mockFn.AsStdFunction()); - EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTIMEOUT)); + EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTimeout)); task.stop(); task.stop(); @@ -100,7 +100,7 @@ TYPED_TEST(RepeatedTaskTypedTest, DestructorStopsTask) task.run(this->mockFn.AsStdFunction()); - EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTIMEOUT)); + EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTimeout)); // Destructor will call stop() } @@ -149,8 +149,8 @@ TEST_F(RepeatedTaskTest, MultipleTasksRunConcurrently) task1.run(mockFn1.AsStdFunction()); task2.run(mockFn2.AsStdFunction()); - EXPECT_TRUE(semaphore1.try_acquire_for(kTIMEOUT)); - EXPECT_TRUE(semaphore2.try_acquire_for(kTIMEOUT)); + EXPECT_TRUE(semaphore1.try_acquire_for(kTimeout)); + EXPECT_TRUE(semaphore2.try_acquire_for(kTimeout)); task1.stop(); task2.stop(); @@ -166,7 +166,7 @@ TYPED_TEST(RepeatedTaskTypedTest, TaskStateTransitionsCorrectly) task.run(this->mockFn.AsStdFunction()); - EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTIMEOUT)); + EXPECT_TRUE(this->semaphore.try_acquire_for(TestFixture::kTimeout)); task.stop(); @@ -200,7 +200,7 @@ TEST_F(RepeatedTaskTest, FunctionCanAccessYieldContext) task.run(mockFn.AsStdFunction()); - EXPECT_TRUE(semaphore.try_acquire_for(kTIMEOUT)); + EXPECT_TRUE(semaphore.try_acquire_for(kTimeout)); task.stop(); diff --git a/tests/unit/data/AmendmentCenterTests.cpp b/tests/unit/data/AmendmentCenterTests.cpp index 5dd1265a0..6acee000b 100644 --- a/tests/unit/data/AmendmentCenterTests.cpp +++ b/tests/unit/data/AmendmentCenterTests.cpp @@ -20,7 +20,7 @@ using namespace data; -constexpr auto kSEQ = 30u; +constexpr auto kSeq = 30u; struct AmendmentCenterTest : util::prometheus::WithPrometheus, MockBackendTest, @@ -70,25 +70,25 @@ TEST_F(AmendmentCenterTest, IsEnabled) EXPECT_FALSE(amendmentCenter.isSupported("unknown")); auto const amendments = createAmendmentsObject({Amendments::fixUniversalNumber}); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSeq, testing::_)) .WillRepeatedly(testing::Return(amendments.getSerializer().peekData())); - EXPECT_TRUE(amendmentCenter.isEnabled("fixUniversalNumber", kSEQ)); - EXPECT_FALSE(amendmentCenter.isEnabled("unknown", kSEQ)); - EXPECT_FALSE(amendmentCenter.isEnabled("ImmediateOfferKilled", kSEQ)); + EXPECT_TRUE(amendmentCenter.isEnabled("fixUniversalNumber", kSeq)); + EXPECT_FALSE(amendmentCenter.isEnabled("unknown", kSeq)); + EXPECT_FALSE(amendmentCenter.isEnabled("ImmediateOfferKilled", kSeq)); } TEST_F(AmendmentCenterTest, IsMultipleEnabled) { auto const amendments = createAmendmentsObject({Amendments::fixUniversalNumber}); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSeq, testing::_)) .WillOnce(testing::Return(amendments.getSerializer().peekData())); runSpawn([this](auto yield) { std::vector const keys{ "fixUniversalNumber", "unknown", "ImmediateOfferKilled" }; - auto const result = amendmentCenter.isEnabled(yield, keys, kSEQ); + auto const result = amendmentCenter.isEnabled(yield, keys, kSeq); EXPECT_EQ(result.size(), keys.size()); EXPECT_TRUE(result.at(0)); @@ -99,34 +99,34 @@ TEST_F(AmendmentCenterTest, IsMultipleEnabled) TEST_F(AmendmentCenterTest, IsEnabledReturnsFalseWhenAmendmentsLedgerObjectUnavailable) { - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSeq, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([this](auto yield) { - EXPECT_NO_THROW(EXPECT_FALSE(amendmentCenter.isEnabled(yield, "irrelevant", kSEQ))); + EXPECT_NO_THROW(EXPECT_FALSE(amendmentCenter.isEnabled(yield, "irrelevant", kSeq))); }); } TEST_F(AmendmentCenterTest, IsEnabledReturnsFalseWhenNoAmendments) { auto const amendments = createBrokenAmendmentsObject(); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSeq, testing::_)) .WillOnce(testing::Return(amendments.getSerializer().peekData())); runSpawn([this](auto yield) { - EXPECT_FALSE(amendmentCenter.isEnabled(yield, "irrelevant", kSEQ)); + EXPECT_FALSE(amendmentCenter.isEnabled(yield, "irrelevant", kSeq)); }); } TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenAmendmentsLedgerObjectUnavailable) { - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSeq, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([this](auto yield) { std::vector const keys{"fixUniversalNumber", "ImmediateOfferKilled"}; std::vector vec; - EXPECT_NO_THROW(vec = amendmentCenter.isEnabled(yield, keys, kSEQ)); + EXPECT_NO_THROW(vec = amendmentCenter.isEnabled(yield, keys, kSeq)); EXPECT_EQ(vec.size(), keys.size()); EXPECT_TRUE(std::ranges::all_of(vec, std::logical_not<>{})); @@ -136,12 +136,12 @@ TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenAmendmentsLedgerObj TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenNoAmendments) { auto const amendments = createBrokenAmendmentsObject(); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSeq, testing::_)) .WillOnce(testing::Return(amendments.getSerializer().peekData())); runSpawn([this](auto yield) { std::vector const keys{"fixUniversalNumber", "ImmediateOfferKilled"}; - auto const vec = amendmentCenter.isEnabled(yield, keys, kSEQ); + auto const vec = amendmentCenter.isEnabled(yield, keys, kSeq); EXPECT_EQ(vec.size(), keys.size()); EXPECT_TRUE(std::ranges::all_of(vec, [](bool val) { return val == false; })); diff --git a/tests/unit/data/BackendCountersTests.cpp b/tests/unit/data/BackendCountersTests.cpp index 789a6538b..c8baa7c87 100644 --- a/tests/unit/data/BackendCountersTests.cpp +++ b/tests/unit/data/BackendCountersTests.cpp @@ -136,15 +136,15 @@ TEST_F(BackendCountersTest, RegisterReadFinished) TEST_F(BackendCountersTest, RegisterReadStartedFinishedWithCounters) { - static constexpr auto kOPERATIONS_STARTED = 7u; - static constexpr auto kOPERATIONS_COMPLETED = 4u; + static constexpr auto kOperationsStarted = 7u; + static constexpr auto kOperationsCompleted = 4u; - counters->registerReadStarted(kOPERATIONS_STARTED); - counters->registerReadFinished(startTime, kOPERATIONS_COMPLETED); + counters->registerReadStarted(kOperationsStarted); + counters->registerReadFinished(startTime, kOperationsCompleted); auto expectedReport = emptyReport(); - expectedReport["read_async_pending"] = kOPERATIONS_STARTED - kOPERATIONS_COMPLETED; - expectedReport["read_async_completed"] = kOPERATIONS_COMPLETED; + expectedReport["read_async_pending"] = kOperationsStarted - kOperationsCompleted; + expectedReport["read_async_completed"] = kOperationsCompleted; EXPECT_EQ(counters->report(), expectedReport); } @@ -160,19 +160,19 @@ TEST_F(BackendCountersTest, RegisterReadRetry) TEST_F(BackendCountersTest, RegisterReadError) { - static constexpr auto kOPERATIONS_STARTED = 7u; - static constexpr auto kOPERATIONS_ERROR = 2u; - static constexpr auto kOPERATIONS_COMPLETED = 1u; + static constexpr auto kOperationsStarted = 7u; + static constexpr auto kOperationsError = 2u; + static constexpr auto kOperationsCompleted = 1u; - counters->registerReadStarted(kOPERATIONS_STARTED); - counters->registerReadError(kOPERATIONS_ERROR); - counters->registerReadFinished(startTime, kOPERATIONS_COMPLETED); + counters->registerReadStarted(kOperationsStarted); + counters->registerReadError(kOperationsError); + counters->registerReadFinished(startTime, kOperationsCompleted); auto expectedReport = emptyReport(); expectedReport["read_async_pending"] = - kOPERATIONS_STARTED - kOPERATIONS_COMPLETED - kOPERATIONS_ERROR; - expectedReport["read_async_completed"] = kOPERATIONS_COMPLETED; - expectedReport["read_async_error"] = kOPERATIONS_ERROR; + kOperationsStarted - kOperationsCompleted - kOperationsError; + expectedReport["read_async_completed"] = kOperationsCompleted; + expectedReport["read_async_error"] = kOperationsError; EXPECT_EQ(counters->report(), expectedReport); } diff --git a/tests/unit/data/BackendInterfaceTests.cpp b/tests/unit/data/BackendInterfaceTests.cpp index 9d5d25031..da47f05c3 100644 --- a/tests/unit/data/BackendInterfaceTests.cpp +++ b/tests/unit/data/BackendInterfaceTests.cpp @@ -21,15 +21,15 @@ using namespace testing; namespace { -constexpr auto kMAX_SEQ = 30; -constexpr auto kMIN_SEQ = 10; +constexpr auto kMaxSeq = 30; +constexpr auto kMinSeq = 10; } // namespace struct BackendInterfaceTest : WithPrometheus, MockBackendTestNaggy, SyncAsioContextTest { BackendInterfaceTest() { - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); } }; @@ -38,11 +38,11 @@ TEST_F(BackendInterfaceTest, FetchFeesSuccessPath) using namespace ripple; // New fee setting (after XRPFees amendment) - EXPECT_CALL(*backend_, doFetchLedgerObject(keylet::fees().key, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(keylet::fees().key, kMaxSeq, _)) .WillRepeatedly(Return(createFeeSettingBlob(XRPAmount(1), XRPAmount(2), XRPAmount(3), 0))); runSpawn([this](auto yield) { - auto fees = backend_->fetchFees(kMAX_SEQ, yield); + auto fees = backend_->fetchFees(kMaxSeq, yield); EXPECT_TRUE(fees.has_value()); EXPECT_EQ(fees->base, XRPAmount(1)); @@ -56,11 +56,11 @@ TEST_F(BackendInterfaceTest, FetchFeesLegacySuccessPath) using namespace ripple; // Legacy fee setting (before XRPFees amendment) - EXPECT_CALL(*backend_, doFetchLedgerObject(keylet::fees().key, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(keylet::fees().key, kMaxSeq, _)) .WillRepeatedly(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); runSpawn([this](auto yield) { - auto fees = backend_->fetchFees(kMAX_SEQ, yield); + auto fees = backend_->fetchFees(kMaxSeq, yield); EXPECT_TRUE(fees.has_value()); EXPECT_EQ(fees->base, XRPAmount(1)); @@ -86,7 +86,7 @@ TEST_F(BackendInterfaceTest, FetchLedgerPageSuccessPath) .WillOnce(Return(std::vector(10, Blob{'s'}))); runSpawn([this](auto yield) { - backend_->fetchLedgerPage(std::nullopt, kMAX_SEQ, 10, false, yield); + backend_->fetchLedgerPage(std::nullopt, kMaxSeq, 10, false, yield); }); EXPECT_FALSE(backend_->cache().isDisabled()); } @@ -121,7 +121,7 @@ TEST_F(BackendInterfaceTest, FetchLedgerPageDisablesCacheOnMissingData) )); runSpawn([this](auto yield) { - backend_->fetchLedgerPage(std::nullopt, kMAX_SEQ, 10, false, yield); + backend_->fetchLedgerPage(std::nullopt, kMaxSeq, 10, false, yield); }); EXPECT_TRUE(backend_->cache().isDisabled()); } @@ -156,7 +156,7 @@ TEST_F( )); runSpawn([this](auto yield) { - backend_->fetchLedgerPage(std::nullopt, kMAX_SEQ, 10, false, yield); + backend_->fetchLedgerPage(std::nullopt, kMaxSeq, 10, false, yield); }); EXPECT_FALSE(backend_->cache().isDisabled()); } diff --git a/tests/unit/data/LedgerCacheSaverTests.cpp b/tests/unit/data/LedgerCacheSaverTests.cpp index 3811de020..c6fd4c83c 100644 --- a/tests/unit/data/LedgerCacheSaverTests.cpp +++ b/tests/unit/data/LedgerCacheSaverTests.cpp @@ -25,7 +25,7 @@ using namespace util::config; struct LedgerCacheSaverTest : virtual testing::Test { testing::StrictMock cache; - constexpr static auto kFILE_PATH = "./cache.bin"; + constexpr static auto kFilePath = "./cache.bin"; static ClioConfigDefinition generateConfig(bool cacheFilePathHasValue, bool asyncSave) @@ -41,7 +41,7 @@ struct LedgerCacheSaverTest : virtual testing::Test { boost::json::parse( fmt::format( R"JSON({{"cache": {{"file": {{"path": "{}", "async_save": {} }} }} }})JSON", - kFILE_PATH, + kFilePath, asyncSave ) ) @@ -59,7 +59,7 @@ TEST_F(LedgerCacheSaverTest, SaveSuccessfully) auto const config = generateConfig(/* cacheFilePathHasValue = */ true, /* asyncSave = */ true); LedgerCacheSaver saver{config, cache}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)) + EXPECT_CALL(cache, saveToFile(kFilePath)) .WillOnce(testing::Return(std::expected{})); saver.save(); @@ -71,7 +71,7 @@ TEST_F(LedgerCacheSaverTest, SaveWithError) auto const config = generateConfig(/* cacheFilePathHasValue = */ true, /* asyncSave = */ true); LedgerCacheSaver saver{config, cache}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)) + EXPECT_CALL(cache, saveToFile(kFilePath)) .WillOnce( testing::Return(std::expected(std::unexpected("Failed to save"))) ); @@ -96,7 +96,7 @@ TEST_F(LedgerCacheSaverTest, DestructorWaitsForCompletion) std::binary_semaphore semaphore{1}; std::atomic_bool saveCompleted{false}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)).WillOnce([&]() { + EXPECT_CALL(cache, saveToFile(kFilePath)).WillOnce([&]() { semaphore.release(); std::this_thread::sleep_for(std::chrono::milliseconds(10)); saveCompleted = true; @@ -117,7 +117,7 @@ TEST_F(LedgerCacheSaverTest, WaitToFinishCanBeCalledMultipleTimes) auto const config = generateConfig(/* cacheFilePathHasValue = */ true, /* asyncSave = */ true); LedgerCacheSaver saver{config, cache}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)); + EXPECT_CALL(cache, saveToFile(kFilePath)); saver.save(); saver.waitToFinish(); @@ -140,7 +140,7 @@ TEST_F(LedgerCacheSaverAssertTest, MultipleSavesNotAllowed) LedgerCacheSaver saver{config, cache}; std::binary_semaphore semaphore{0}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)).WillOnce([&](auto&&) { + EXPECT_CALL(cache, saveToFile(kFilePath)).WillOnce([&](auto&&) { semaphore.acquire(); return std::expected{}; }); @@ -157,7 +157,7 @@ TEST_F(LedgerCacheSaverTest, SyncSaveWaitsForCompletion) std::atomic_bool saveCompleted{false}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)).WillOnce([&]() { + EXPECT_CALL(cache, saveToFile(kFilePath)).WillOnce([&]() { std::this_thread::sleep_for(std::chrono::milliseconds(50)); saveCompleted = true; return std::expected{}; @@ -176,7 +176,7 @@ TEST_F(LedgerCacheSaverTest, AsyncSaveDoesNotWaitForCompletion) std::binary_semaphore continueExecution{0}; std::atomic_bool saveCompleted{false}; - EXPECT_CALL(cache, saveToFile(kFILE_PATH)).WillOnce([&]() { + EXPECT_CALL(cache, saveToFile(kFilePath)).WillOnce([&]() { saveStarted.release(); continueExecution.acquire(); saveCompleted = true; diff --git a/tests/unit/data/LedgerCacheTests.cpp b/tests/unit/data/LedgerCacheTests.cpp index 6a93b9ac6..4aea03f9e 100644 --- a/tests/unit/data/LedgerCacheTests.cpp +++ b/tests/unit/data/LedgerCacheTests.cpp @@ -106,7 +106,7 @@ struct LedgerCacheSaveLoadTest : LedgerCacheTest { .type = {} } }; - uint32_t const kLEDGER_SEQ = 100; + uint32_t const kLedgerSeq = 100; }; TEST_F(LedgerCacheSaveLoadTest, saveToFileFailsWhenCacheNotFull) @@ -120,18 +120,18 @@ TEST_F(LedgerCacheSaveLoadTest, saveToFileFailsWhenCacheNotFull) TEST_F(LedgerCacheSaveLoadTest, saveAndLoadFromFile) { - cache.update(objs, kLEDGER_SEQ); + cache.update(objs, kLedgerSeq); cache.setFull(); ASSERT_TRUE(cache.isFull()); EXPECT_EQ(cache.size(), 2u); - EXPECT_EQ(cache.latestLedgerSequence(), kLEDGER_SEQ); + EXPECT_EQ(cache.latestLedgerSequence(), kLedgerSeq); - auto const blob1 = cache.get(key1, kLEDGER_SEQ); + auto const blob1 = cache.get(key1, kLedgerSeq); ASSERT_TRUE(blob1.has_value()); EXPECT_EQ(blob1.value(), objs.front().data); // NOLINT(bugprone-unchecked-optional-access) - auto const blob2 = cache.get(key2, kLEDGER_SEQ); + auto const blob2 = cache.get(key2, kLedgerSeq); ASSERT_TRUE(blob2.has_value()); EXPECT_EQ(blob2.value(), objs.back().data); // NOLINT(bugprone-unchecked-optional-access) @@ -145,13 +145,13 @@ TEST_F(LedgerCacheSaveLoadTest, saveAndLoadFromFile) EXPECT_TRUE(newCache.isFull()); EXPECT_EQ(newCache.size(), 2u); - EXPECT_EQ(newCache.latestLedgerSequence(), kLEDGER_SEQ); + EXPECT_EQ(newCache.latestLedgerSequence(), kLedgerSeq); - auto const loadedBlob1 = newCache.get(key1, kLEDGER_SEQ); + auto const loadedBlob1 = newCache.get(key1, kLedgerSeq); ASSERT_TRUE(loadedBlob1.has_value()); EXPECT_EQ(loadedBlob1.value(), blob1); // NOLINT(bugprone-unchecked-optional-access) - auto const loadedBlob2 = newCache.get(key2, kLEDGER_SEQ); + auto const loadedBlob2 = newCache.get(key2, kLedgerSeq); ASSERT_TRUE(loadedBlob2.has_value()); EXPECT_EQ(loadedBlob2.value(), blob2); // NOLINT(bugprone-unchecked-optional-access) @@ -160,23 +160,23 @@ TEST_F(LedgerCacheSaveLoadTest, saveAndLoadFromFile) TEST_F(LedgerCacheSaveLoadTest, saveAndLoadFromFileWithDeletedObjects) { - cache.update(objs, kLEDGER_SEQ - 1); + cache.update(objs, kLedgerSeq - 1); auto objsCopy = objs; objsCopy.front().data = {}; - cache.update(objsCopy, kLEDGER_SEQ); + cache.update(objsCopy, kLedgerSeq); cache.setFull(); // Verify deleted object is accessible via getDeleted - auto const blob1 = cache.get(key1, kLEDGER_SEQ); + auto const blob1 = cache.get(key1, kLedgerSeq); ASSERT_FALSE(blob1.has_value()); - auto const blob2 = cache.get(key2, kLEDGER_SEQ); + auto const blob2 = cache.get(key2, kLedgerSeq); ASSERT_TRUE(blob2.has_value()); EXPECT_EQ(blob2.value(), objs.back().data); // NOLINT(bugprone-unchecked-optional-access) - auto const deletedBlob = cache.getDeleted(key1, kLEDGER_SEQ - 1); + auto const deletedBlob = cache.getDeleted(key1, kLedgerSeq - 1); ASSERT_TRUE(deletedBlob.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) EXPECT_EQ(deletedBlob.value(), objs.front().data); @@ -191,16 +191,16 @@ TEST_F(LedgerCacheSaveLoadTest, saveAndLoadFromFileWithDeletedObjects) ASSERT_TRUE(loadResult.has_value()) << "Load failed: " << loadResult.error(); // Verify deleted object is preserved - auto const loadedDeletedBlob = newCache.getDeleted(key1, kLEDGER_SEQ - 1); + auto const loadedDeletedBlob = newCache.getDeleted(key1, kLedgerSeq - 1); ASSERT_TRUE(loadedDeletedBlob.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) EXPECT_EQ(loadedDeletedBlob.value(), deletedBlob); // Verify active object - auto const loadedBlob1 = newCache.get(key1, kLEDGER_SEQ); + auto const loadedBlob1 = newCache.get(key1, kLedgerSeq); ASSERT_FALSE(loadedBlob1.has_value()); - auto const loadedBlob2 = newCache.get(key2, kLEDGER_SEQ); + auto const loadedBlob2 = newCache.get(key2, kLedgerSeq); ASSERT_TRUE(loadedBlob2.has_value()); EXPECT_EQ(loadedBlob2.value(), blob2); // NOLINT(bugprone-unchecked-optional-access) diff --git a/tests/unit/data/cassandra/ExecutionStrategyTests.cpp b/tests/unit/data/cassandra/ExecutionStrategyTests.cpp index 8707cae13..bd26d9f09 100644 --- a/tests/unit/data/cassandra/ExecutionStrategyTests.cpp +++ b/tests/unit/data/cassandra/ExecutionStrategyTests.cpp @@ -84,7 +84,7 @@ protected: MockHandle handle_{}; MockBackendCounters::PtrType counters_ = MockBackendCounters::make(); - static constexpr auto kNUM_STATEMENTS = 3u; + static constexpr auto kNumStatements = 3u; DefaultExecutionStrategy makeStrategy(Settings s = {}) @@ -197,7 +197,7 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadBatchInCoroutineSuccessful) ) ) .WillByDefault([](auto const& statements, auto&& cb) { - EXPECT_EQ(statements.size(), kNUM_STATEMENTS); + EXPECT_EQ(statements.size(), kNumStatements); cb({}); // pretend we got data return FakeFutureWithCallback{}; }); @@ -208,11 +208,11 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadBatchInCoroutineSuccessful) ) ) .Times(1); - EXPECT_CALL(*counters_, registerReadStartedImpl(kNUM_STATEMENTS)); - EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, kNUM_STATEMENTS)); + EXPECT_CALL(*counters_, registerReadStartedImpl(kNumStatements)); + EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, kNumStatements)); runSpawn([&strat](boost::asio::yield_context yield) { - auto statements = std::vector(kNUM_STATEMENTS); + auto statements = std::vector(kNumStatements); strat.read(yield, statements); }); } @@ -228,7 +228,7 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadBatchInCoroutineThrowsOnTimeou ) ) .WillByDefault([](auto const& statements, auto&& cb) { - EXPECT_EQ(statements.size(), kNUM_STATEMENTS); + EXPECT_EQ(statements.size(), kNumStatements); auto res = FakeResultOrError{CassandraError{"timeout", CASS_ERROR_LIB_REQUEST_TIMED_OUT}}; cb(res); // notify that item is ready @@ -241,11 +241,11 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadBatchInCoroutineThrowsOnTimeou ) ) .Times(1); - EXPECT_CALL(*counters_, registerReadStartedImpl(kNUM_STATEMENTS)); - EXPECT_CALL(*counters_, registerReadErrorImpl(kNUM_STATEMENTS)); + EXPECT_CALL(*counters_, registerReadStartedImpl(kNumStatements)); + EXPECT_CALL(*counters_, registerReadErrorImpl(kNumStatements)); runSpawn([&strat](boost::asio::yield_context yield) { - auto statements = std::vector(kNUM_STATEMENTS); + auto statements = std::vector(kNumStatements); EXPECT_THROW(strat.read(yield, statements), data::DatabaseTimeout); }); } @@ -261,7 +261,7 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadBatchInCoroutineThrowsOnInvali ) ) .WillByDefault([](auto const& statements, auto&& cb) { - EXPECT_EQ(statements.size(), kNUM_STATEMENTS); + EXPECT_EQ(statements.size(), kNumStatements); auto res = FakeResultOrError{CassandraError{"invalid", CASS_ERROR_SERVER_INVALID_QUERY}}; cb(res); // notify that item is ready @@ -274,11 +274,11 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadBatchInCoroutineThrowsOnInvali ) ) .Times(1); - EXPECT_CALL(*counters_, registerReadStartedImpl(kNUM_STATEMENTS)); - EXPECT_CALL(*counters_, registerReadErrorImpl(kNUM_STATEMENTS)); + EXPECT_CALL(*counters_, registerReadStartedImpl(kNumStatements)); + EXPECT_CALL(*counters_, registerReadErrorImpl(kNumStatements)); runSpawn([&strat](boost::asio::yield_context yield) { - auto statements = std::vector(kNUM_STATEMENTS); + auto statements = std::vector(kNumStatements); EXPECT_THROW(strat.read(yield, statements), std::runtime_error); }); } @@ -297,7 +297,7 @@ TEST_F( ) ) .WillByDefault([this, &strat](auto const& statements, auto&& cb) { - EXPECT_EQ(statements.size(), kNUM_STATEMENTS); + EXPECT_EQ(statements.size(), kNumStatements); EXPECT_CALL(*counters_, registerTooBusy()); EXPECT_TRUE(strat.isTooBusy()); // 2 was the limit, we sent 3 @@ -311,12 +311,12 @@ TEST_F( ) ) .Times(1); - EXPECT_CALL(*counters_, registerReadStartedImpl(kNUM_STATEMENTS)); - EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, kNUM_STATEMENTS)); + EXPECT_CALL(*counters_, registerReadStartedImpl(kNumStatements)); + EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, kNumStatements)); runSpawn([&strat](boost::asio::yield_context yield) { EXPECT_FALSE(strat.isTooBusy()); // 2 was the limit, 0 atm - auto statements = std::vector(kNUM_STATEMENTS); + auto statements = std::vector(kNumStatements); strat.read(yield, statements); EXPECT_FALSE(strat.isTooBusy()); // after read completes it's 0 again }); @@ -341,12 +341,12 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadEachInCoroutineSuccessful) A&&>() ) ) - .Times(kNUM_STATEMENTS); // once per statement - EXPECT_CALL(*counters_, registerReadStartedImpl(kNUM_STATEMENTS)); - EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, kNUM_STATEMENTS)); + .Times(kNumStatements); // once per statement + EXPECT_CALL(*counters_, registerReadStartedImpl(kNumStatements)); + EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, kNumStatements)); runSpawn([&strat](boost::asio::yield_context yield) { - auto statements = std::vector(kNUM_STATEMENTS); + auto statements = std::vector(kNumStatements); auto res = strat.readEach(yield, statements); EXPECT_EQ(res.size(), statements.size()); }); @@ -377,13 +377,13 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadEachInCoroutineThrowsOnFailure A&&>() ) ) - .Times(kNUM_STATEMENTS); // once per statement - EXPECT_CALL(*counters_, registerReadStartedImpl(kNUM_STATEMENTS)); + .Times(kNumStatements); // once per statement + EXPECT_CALL(*counters_, registerReadStartedImpl(kNumStatements)); EXPECT_CALL(*counters_, registerReadErrorImpl(1)); EXPECT_CALL(*counters_, registerReadFinishedImpl(testing::_, 2)); runSpawn([&strat](boost::asio::yield_context yield) { - auto statements = std::vector(kNUM_STATEMENTS); + auto statements = std::vector(kNumStatements); EXPECT_THROW(strat.readEach(yield, statements), data::DatabaseTimeout); }); } diff --git a/tests/unit/data/cassandra/LedgerHeaderCacheTests.cpp b/tests/unit/data/cassandra/LedgerHeaderCacheTests.cpp index a381802e0..0834494dd 100644 --- a/tests/unit/data/cassandra/LedgerHeaderCacheTests.cpp +++ b/tests/unit/data/cassandra/LedgerHeaderCacheTests.cpp @@ -6,8 +6,8 @@ using namespace data; using Test = ::testing::Test; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kLEDGER_HASH2 = +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constinit auto const kLedgerHasH2 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; class FetchLedgerCacheTest : public Test { @@ -23,7 +23,7 @@ TEST_F(FetchLedgerCacheTest, DefaultCacheIsEmpty) TEST_F(FetchLedgerCacheTest, CanStoreAndRetrieveEntry) { - auto const ledger = createLedgerHeader(kLEDGER_HASH, 42); + auto const ledger = createLedgerHeader(kLedgerHash, 42); FetchLedgerCache::CacheEntry const entry{.ledger = ledger, .seq = 42}; cache_.put(entry); @@ -35,8 +35,8 @@ TEST_F(FetchLedgerCacheTest, CanStoreAndRetrieveEntry) TEST_F(FetchLedgerCacheTest, PutOverwritesPreviousEntry) { - auto const ledger1 = createLedgerHeader(kLEDGER_HASH, 1); - auto const ledger2 = createLedgerHeader(kLEDGER_HASH2, 2); + auto const ledger1 = createLedgerHeader(kLedgerHash, 1); + auto const ledger2 = createLedgerHeader(kLedgerHasH2, 2); FetchLedgerCache::CacheEntry const entry1{.ledger = ledger1, .seq = 1}; FetchLedgerCache::CacheEntry const entry2{.ledger = ledger2, .seq = 2}; diff --git a/tests/unit/data/impl/LedgerCacheFileTests.cpp b/tests/unit/data/impl/LedgerCacheFileTests.cpp index 60f3b26b2..20a47e321 100644 --- a/tests/unit/data/impl/LedgerCacheFileTests.cpp +++ b/tests/unit/data/impl/LedgerCacheFileTests.cpp @@ -129,17 +129,17 @@ struct LedgerCacheFileTestBase : ::testing::Test { std::filesystem::remove(pathWithNewPrefix); } - static std::vector const kDATA_SIZE_PARAMS; - static std::vector const kCORRUPTION_PARAMS; + static std::vector const kDataSizeParams; + static std::vector const kCorruptionParams; TmpFile tmpFile = TmpFile::empty(); - static uint32_t constexpr kLATEST_SEQUENCE = 12345; + static uint32_t constexpr kLatestSequence = 12345; static LedgerCacheFile::Data createTestData(size_t mapSize, size_t deletedSize, size_t blobSize) { LedgerCacheFile::Data data; - data.latestSeq = kLATEST_SEQUENCE; + data.latestSeq = kLatestSequence; for (size_t i = 0; i < mapSize; ++i) { ripple::uint256 key; @@ -307,7 +307,7 @@ struct LedgerCacheFileTestBase : ::testing::Test { }; std::vector< - LedgerCacheFileTestBase::DataSizeParams> const LedgerCacheFileTestBase::kDATA_SIZE_PARAMS = { + LedgerCacheFileTestBase::DataSizeParams> const LedgerCacheFileTestBase::kDataSizeParams = { {.mapEntries = 0, .deletedEntries = 0, .blobSize = 0, .description = "empty"}, {.mapEntries = 1, .deletedEntries = 0, .blobSize = 10, .description = "single_map_small_blob"}, {.mapEntries = 0, @@ -325,7 +325,7 @@ std::vector< }; std::vector const - LedgerCacheFileTestBase::kCORRUPTION_PARAMS = { + LedgerCacheFileTestBase::kCorruptionParams = { {.type = CorruptionType::InvalidVersion, .description = "invalid_version"}, {.type = CorruptionType::CorruptedSeparator1, .description = "corrupted_separator1"}, {.type = CorruptionType::CorruptedSeparator2, .description = "corrupted_separator2"}, @@ -357,7 +357,7 @@ struct LedgerCacheFileTest INSTANTIATE_TEST_SUITE_P( AllDataSizes, LedgerCacheFileTest, - ::testing::ValuesIn(LedgerCacheFileTestBase::kDATA_SIZE_PARAMS), + ::testing::ValuesIn(LedgerCacheFileTestBase::kDataSizeParams), LedgerCacheFileTest::roundTripParamName ); @@ -395,7 +395,7 @@ struct LedgerCacheFileCorruptionTest INSTANTIATE_TEST_SUITE_P( AllCorruptions, LedgerCacheFileCorruptionTest, - ::testing::ValuesIn(LedgerCacheFileTestBase::kCORRUPTION_PARAMS), + ::testing::ValuesIn(LedgerCacheFileTestBase::kCorruptionParams), LedgerCacheFileCorruptionTest::corruptionParamName ); @@ -701,7 +701,7 @@ INSTANTIATE_TEST_SUITE_P( .testName = "accept_zero_sequence" } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(LedgerCacheFileMinSequenceValidationTest, ValidateMinSequence) diff --git a/tests/unit/etl/AmendmentBlockHandlerTests.cpp b/tests/unit/etl/AmendmentBlockHandlerTests.cpp index f5f0d3fb3..c4fd37687 100644 --- a/tests/unit/etl/AmendmentBlockHandlerTests.cpp +++ b/tests/unit/etl/AmendmentBlockHandlerTests.cpp @@ -23,7 +23,7 @@ protected: TEST_F(AmendmentBlockHandlerTests, CallToNotifyAmendmentBlockedSetsStateAndRepeatedlyCallsAction) { - static constexpr auto kMAX_ITERATIONS = 10uz; + static constexpr auto kMaxIterations = 10uz; etl::impl::AmendmentBlockHandler handler{ ctx_, state_, std::chrono::nanoseconds{1}, actionMock_.AsStdFunction() }; @@ -32,12 +32,12 @@ TEST_F(AmendmentBlockHandlerTests, CallToNotifyAmendmentBlockedSetsStateAndRepea EXPECT_FALSE(state_.isAmendmentBlocked); EXPECT_CALL(actionMock_, Call()).Times(testing::AtLeast(10)).WillRepeatedly([&]() { - if (++counter; counter > kMAX_ITERATIONS) + if (++counter; counter > kMaxIterations) stop.release(); }); handler.notifyAmendmentBlocked(); - stop.acquire(); // wait for the counter to reach over kMAX_ITERATIONS + stop.acquire(); // wait for the counter to reach over kMaxIterations handler.stop(); EXPECT_TRUE(state_.isAmendmentBlocked); @@ -47,7 +47,7 @@ struct DefaultAmendmentBlockActionTest : LoggerFixture {}; TEST_F(DefaultAmendmentBlockActionTest, Call) { - AmendmentBlockHandler::kDEFAULT_AMENDMENT_BLOCK_ACTION(); + AmendmentBlockHandler::kDefaultAmendmentBlockAction(); auto const loggerString = getLoggerString(); EXPECT_TRUE(loggerString.starts_with("cri:ETL - Can't process new ledgers")) << "LoggerString " << loggerString; diff --git a/tests/unit/etl/CacheLoaderSettingsTests.cpp b/tests/unit/etl/CacheLoaderSettingsTests.cpp index cef6243da..c4540785c 100644 --- a/tests/unit/etl/CacheLoaderSettingsTests.cpp +++ b/tests/unit/etl/CacheLoaderSettingsTests.cpp @@ -123,15 +123,15 @@ TEST_F(CacheLoaderSettingsTest, NoLoadStyleCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, CacheFilePathCorrectlyPropagatedThroughConfig) { - static constexpr auto kCACHE_FILE_PATH = "/path/to/cache.dat"; + static constexpr auto kCacheFilePath = "/path/to/cache.dat"; auto const jsonStr = - fmt::format(R"JSON({{"cache": {{"file": {{"path": "{}"}}}}}})JSON", kCACHE_FILE_PATH); + fmt::format(R"JSON({{"cache": {{"file": {{"path": "{}"}}}}}})JSON", kCacheFilePath); auto const cfg = getParseCacheConfig(json::parse(jsonStr)); auto const settings = makeCacheLoaderSettings(cfg); ASSERT_TRUE(settings.cacheFileSettings.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(settings.cacheFileSettings->path, kCACHE_FILE_PATH); + EXPECT_EQ(settings.cacheFileSettings->path, kCacheFilePath); } TEST_F(CacheLoaderSettingsTest, CacheFilePathNotSetWhenAbsentFromConfig) diff --git a/tests/unit/etl/CacheLoaderTests.cpp b/tests/unit/etl/CacheLoaderTests.cpp index 61df612ed..b4fea254c 100644 --- a/tests/unit/etl/CacheLoaderTests.cpp +++ b/tests/unit/etl/CacheLoaderTests.cpp @@ -61,7 +61,7 @@ getParseCacheConfig(boost::json::value val) return config; } -constexpr auto kSEQ = 30; +constexpr auto kSeq = 30; struct CacheLoaderTest : util::prometheus::WithPrometheus, MockBackendTest { DiffProvider diffProvider; @@ -188,11 +188,11 @@ TEST_P(ParametrizedCacheLoaderTest, LoadCacheWithDifferentSettings) auto const keysSize = 14; EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).WillRepeatedly(Return(diffs)); - EXPECT_CALL(*backend_, doFetchSuccessorKey(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchSuccessorKey(_, kSeq, _)) .Times(keysSize * loops) .WillRepeatedly([this]() { return diffProvider.nextKey(keysSize); }); - EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSeq, _)) .WillRepeatedly(Return(std::vector(keysSize - 1, Blob{'s'}))); EXPECT_CALL(cache, isDisabled).WillRepeatedly(Return(false)); @@ -206,10 +206,10 @@ TEST_P(ParametrizedCacheLoaderTest, LoadCacheWithDifferentSettings) ctx, backend_, cache, - kSEQ, + kSeq, settings.numCacheMarkers, settings.cachePageFetchSize, - provider.getCursors(kSEQ) + provider.getCursors(kSeq) }; loader.wait(); @@ -223,11 +223,11 @@ TEST_P(ParametrizedCacheLoaderTest, AutomaticallyCancelledAndAwaitedInDestructor auto const keysSize = 1024; EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).WillRepeatedly(Return(diffs)); - EXPECT_CALL(*backend_, doFetchSuccessorKey(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchSuccessorKey(_, kSeq, _)) .Times(AtMost(keysSize * loops)) .WillRepeatedly([this]() { return diffProvider.nextKey(keysSize); }); - EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSeq, _)) .WillRepeatedly(Return(std::vector(keysSize - 1, Blob{'s'}))); EXPECT_CALL(cache, isDisabled).WillRepeatedly(Return(false)); @@ -241,10 +241,10 @@ TEST_P(ParametrizedCacheLoaderTest, AutomaticallyCancelledAndAwaitedInDestructor ctx, backend_, cache, - kSEQ, + kSeq, settings.numCacheMarkers, settings.cachePageFetchSize, - provider.getCursors(kSEQ) + provider.getCursors(kSeq) }; // no loader.wait(): loader is immediately stopped and awaited in destructor @@ -258,11 +258,11 @@ TEST_P(ParametrizedCacheLoaderTest, CacheDisabledLeadsToCancellation) auto const keysSize = 1024; EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).WillRepeatedly(Return(diffs)); - EXPECT_CALL(*backend_, doFetchSuccessorKey(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchSuccessorKey(_, kSeq, _)) .Times(AtMost(keysSize * loops)) .WillRepeatedly([this]() { return diffProvider.nextKey(keysSize); }); - EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSeq, _)) .WillRepeatedly(Return(std::vector(keysSize - 1, Blob{'s'}))); EXPECT_CALL(cache, isDisabled).WillOnce(Return(false)).WillRepeatedly(Return(true)); @@ -276,10 +276,10 @@ TEST_P(ParametrizedCacheLoaderTest, CacheDisabledLeadsToCancellation) ctx, backend_, cache, - kSEQ, + kSeq, settings.numCacheMarkers, settings.cachePageFetchSize, - provider.getCursors(kSEQ) + provider.getCursors(kSeq) }; loader.wait(); @@ -302,7 +302,7 @@ TEST_F(CacheLoaderTest, SyncCacheLoaderWaitsTillFullyLoaded) return diffProvider.nextKey(keysSize); }); - EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSeq, _)) .Times(loops) .WillRepeatedly(Return(std::vector{keysSize - 1, Blob{'s'}})); @@ -313,7 +313,7 @@ TEST_F(CacheLoaderTest, SyncCacheLoaderWaitsTillFullyLoaded) EXPECT_CALL(cache, startLoading).Times(1); EXPECT_CALL(cacheLoadingStateRef, waitForLoadingAllowed()); - loader.load(kSEQ); + loader.load(kSeq); } TEST_F(CacheLoaderTest, AsyncCacheLoaderCanBeStopped) @@ -330,7 +330,7 @@ TEST_F(CacheLoaderTest, AsyncCacheLoaderCanBeStopped) .Times(AtMost(keysSize * loops)) .WillRepeatedly([this]() { return diffProvider.nextKey(keysSize); }); - EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSeq, _)) .Times(AtMost(loops)) .WillRepeatedly(Return(std::vector{keysSize - 1, Blob{'s'}})); @@ -341,7 +341,7 @@ TEST_F(CacheLoaderTest, AsyncCacheLoaderCanBeStopped) EXPECT_CALL(cache, startLoading).Times(1); EXPECT_CALL(cacheLoadingStateRef, waitForLoadingAllowed()).Times(1); - loader.load(kSEQ); + loader.load(kSeq); loader.stop(); loader.wait(); } @@ -355,7 +355,7 @@ TEST_F(CacheLoaderTest, DisabledCacheLoaderDoesNotLoadCache) EXPECT_CALL(cache, isFull).WillRepeatedly(Return(false)); EXPECT_CALL(cache, setDisabled).Times(1); - loader.load(kSEQ); + loader.load(kSeq); } TEST_F(CacheLoaderTest, DisabledCacheLoaderCanCallStopAndWait) @@ -367,7 +367,7 @@ TEST_F(CacheLoaderTest, DisabledCacheLoaderCanCallStopAndWait) EXPECT_CALL(cache, isFull).WillRepeatedly(Return(false)); EXPECT_CALL(cache, setDisabled).Times(1); - loader.load(kSEQ); + loader.load(kSeq); EXPECT_NO_THROW(loader.stop()); EXPECT_NO_THROW(loader.wait()); @@ -376,7 +376,7 @@ TEST_F(CacheLoaderTest, DisabledCacheLoaderCanCallStopAndWait) struct CacheLoaderFromFileTest : CacheLoaderTest { CacheLoaderFromFileTest() { - backend_->setRange(kSEQ - 20, kSEQ); + backend_->setRange(kSeq - 20, kSeq); } std::string const filePath = "./cache.bin"; @@ -395,18 +395,18 @@ struct CacheLoaderFromFileTest : CacheLoaderTest { TEST_F(CacheLoaderFromFileTest, Success) { - constexpr uint32_t kLOADED_SEQ = 12345; + constexpr uint32_t kLoadedSeq = 12345; EXPECT_CALL(cache, isFull).WillOnce(Return(false)); - EXPECT_CALL(cache, loadFromFile(filePath, kSEQ - maxSequenceLag)) + EXPECT_CALL(cache, loadFromFile(filePath, kSeq - maxSequenceLag)) .WillOnce(Return(std::expected{})); - EXPECT_CALL(cache, latestLedgerSequence).WillOnce(Return(kLOADED_SEQ)); + EXPECT_CALL(cache, latestLedgerSequence).WillOnce(Return(kLoadedSeq)); EXPECT_CALL(cache, setFull); - loader.load(kSEQ); + loader.load(kSeq); std::optional const expectedLedgerRange = - LedgerRange{.minSequence = kSEQ - 20, .maxSequence = kSEQ}; + LedgerRange{.minSequence = kSeq - 20, .maxSequence = kSeq}; EXPECT_EQ(backend_->fetchLedgerRange(), expectedLedgerRange); } @@ -416,7 +416,7 @@ TEST_F(CacheLoaderFromFileTest, FailureBackToNormalLoad) auto const loops = diffs.size() + 1; auto const keysSize = 14; - EXPECT_CALL(cache, loadFromFile(filePath, kSEQ - maxSequenceLag)) + EXPECT_CALL(cache, loadFromFile(filePath, kSeq - maxSequenceLag)) .WillOnce(Return(std::expected(std::unexpected("File not found")))); EXPECT_CALL(cacheLoadingStateRef, waitForLoadingAllowed()).Times(1); @@ -425,7 +425,7 @@ TEST_F(CacheLoaderFromFileTest, FailureBackToNormalLoad) return diffProvider.nextKey(keysSize); }); - EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjects(_, kSeq, _)) .Times(loops) .WillRepeatedly(Return(std::vector{keysSize - 1, Blob{'s'}})); @@ -435,7 +435,7 @@ TEST_F(CacheLoaderFromFileTest, FailureBackToNormalLoad) EXPECT_CALL(cache, setFull).Times(1); EXPECT_CALL(cache, startLoading).Times(1); - loader.load(kSEQ); + loader.load(kSeq); } TEST_F(CacheLoaderFromFileTest, DontLoadWhenCacheIsDisabled) @@ -450,46 +450,46 @@ TEST_F(CacheLoaderFromFileTest, DontLoadWhenCacheIsDisabled) EXPECT_CALL(cache, isFull).WillOnce(Return(false)); EXPECT_CALL(cache, setDisabled); - loaderWithCacheDisabled.load(kSEQ); + loaderWithCacheDisabled.load(kSeq); } TEST_F(CacheLoaderFromFileTest, MaxSequenceLagCalculation) { - constexpr uint32_t kLOADED_SEQ = 12345; + constexpr uint32_t kLoadedSeq = 12345; EXPECT_CALL(cache, isFull).WillOnce(Return(false)); - EXPECT_CALL(cache, loadFromFile(filePath, kSEQ - maxSequenceLag)) + EXPECT_CALL(cache, loadFromFile(filePath, kSeq - maxSequenceLag)) .WillOnce(Return(std::expected{})); - EXPECT_CALL(cache, latestLedgerSequence).WillOnce(Return(kLOADED_SEQ)); + EXPECT_CALL(cache, latestLedgerSequence).WillOnce(Return(kLoadedSeq)); EXPECT_CALL(cache, setFull).Times(1); - loader.load(kSEQ); + loader.load(kSeq); } TEST_F(CacheLoaderFromFileTest, FileSequenceBehindBackendFetchesMissingLedgersFromDB) { - constexpr uint32_t kFILE_SEQ = kSEQ - 2; + constexpr uint32_t kFileSeq = kSeq - 2; auto const diffs = diffProvider.getLatestDiff(); EXPECT_CALL(cache, isFull).WillOnce(Return(false)); - EXPECT_CALL(cache, loadFromFile(filePath, kSEQ - maxSequenceLag)) + EXPECT_CALL(cache, loadFromFile(filePath, kSeq - maxSequenceLag)) .WillOnce(Return(std::expected{})); // latestLedgerSequence is called twice per loop iteration (condition + seqToLoad + 1) // plus once for the final exit check EXPECT_CALL(cache, latestLedgerSequence) - .WillOnce(Return(kFILE_SEQ)) // iteration 1: condition (true) - .WillOnce(Return(kFILE_SEQ)) // iteration 1: seqToLoad + 1 = kFILE_SEQ + 1 - .WillOnce(Return(kFILE_SEQ + 1)) // iteration 2: condition (true) - .WillOnce(Return(kFILE_SEQ + 1)) // iteration 2: seqToLoad + 1 = kFILE_SEQ + 2 - .WillOnce(Return(kSEQ)); // exit condition (false) + .WillOnce(Return(kFileSeq)) // iteration 1: condition (true) + .WillOnce(Return(kFileSeq)) // iteration 1: seqToLoad + 1 = kFileSeq + 1 + .WillOnce(Return(kFileSeq + 1)) // iteration 2: condition (true) + .WillOnce(Return(kFileSeq + 1)) // iteration 2: seqToLoad + 1 = kFileSeq + 2 + .WillOnce(Return(kSeq)); // exit condition (false) - EXPECT_CALL(*backend_, fetchLedgerDiff(kFILE_SEQ + 1, _)).WillOnce(Return(diffs)); - EXPECT_CALL(*backend_, fetchLedgerDiff(kFILE_SEQ + 2, _)).WillOnce(Return(diffs)); + EXPECT_CALL(*backend_, fetchLedgerDiff(kFileSeq + 1, _)).WillOnce(Return(diffs)); + EXPECT_CALL(*backend_, fetchLedgerDiff(kFileSeq + 2, _)).WillOnce(Return(diffs)); EXPECT_CALL(cache, updateImpl).Times(2); EXPECT_CALL(cache, setFull).Times(1); - loader.load(kSEQ); + loader.load(kSeq); } TEST_F(CacheLoaderFromFileTest, MaxSequenceLagClampedToMinOfLedgerRange) diff --git a/tests/unit/etl/CursorFromAccountProviderTests.cpp b/tests/unit/etl/CursorFromAccountProviderTests.cpp index 098b45812..e1ddc7483 100644 --- a/tests/unit/etl/CursorFromAccountProviderTests.cpp +++ b/tests/unit/etl/CursorFromAccountProviderTests.cpp @@ -16,9 +16,9 @@ using namespace testing; namespace { -constexpr auto kSEQ = 30; +constexpr auto kSeq = 30; -std::vector const kACCOUNT_ROOTS = { +std::vector const kAccountRoots = { ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, @@ -39,13 +39,13 @@ TEST_F(CursorFromAccountProviderTests, EnoughAccountRoots) auto const pageSize = 100; auto const provider = etl::impl::CursorFromAccountProvider{backend_, numCursors, pageSize}; - ON_CALL(*backend_, fetchAccountRoots(numCursors, _, kSEQ, _)) - .WillByDefault(Return(kACCOUNT_ROOTS)); + ON_CALL(*backend_, fetchAccountRoots(numCursors, _, kSeq, _)) + .WillByDefault(Return(kAccountRoots)); EXPECT_CALL(*backend_, fetchAccountRoots(_, _, _, _)).Times(1); - auto const cursors = provider.getCursors(kSEQ); + auto const cursors = provider.getCursors(kSeq); ASSERT_EQ(cursors.size(), numCursors + 1); - EXPECT_EQ(cursors.front().start, kFIRST_KEY); - EXPECT_EQ(cursors.back().end, kLAST_KEY); + EXPECT_EQ(cursors.front().start, kFirstKey); + EXPECT_EQ(cursors.back().end, kLastKey); } diff --git a/tests/unit/etl/CursorFromDiffProviderTests.cpp b/tests/unit/etl/CursorFromDiffProviderTests.cpp index c0b473b2b..f247c9b26 100644 --- a/tests/unit/etl/CursorFromDiffProviderTests.cpp +++ b/tests/unit/etl/CursorFromDiffProviderTests.cpp @@ -16,9 +16,9 @@ using namespace testing; namespace { -constexpr auto kSEQ = 30; +constexpr auto kSeq = 30; -std::vector const kDIFFS_FOR_SEQ = { +std::vector const kDiffsForSeq = { {.key = ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{}}, // This object is removed in Seq while it exists in Seq-1 {.key = ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, @@ -43,7 +43,7 @@ std::vector const kDIFFS_FOR_SEQ = { .blob = Blob{'s'}}, }; -std::vector const kDIFFS_FOR_SEQ_MINUS1 = { +std::vector const kDiffsForSeqMinuS1 = { {.key = ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{'s'}}, {.key = ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD1301"}, @@ -76,16 +76,16 @@ TEST_F(CursorFromDiffProviderTests, MultipleDiffs) auto const numCursors = 15; auto const provider = etl::impl::CursorFromDiffProvider{backend_, numCursors}; - backend_->setRange(kSEQ - 10, kSEQ); - ON_CALL(*backend_, fetchLedgerDiff(kSEQ, _)).WillByDefault(Return(kDIFFS_FOR_SEQ)); - ON_CALL(*backend_, fetchLedgerDiff(kSEQ - 1, _)).WillByDefault(Return(kDIFFS_FOR_SEQ_MINUS1)); + backend_->setRange(kSeq - 10, kSeq); + ON_CALL(*backend_, fetchLedgerDiff(kSeq, _)).WillByDefault(Return(kDiffsForSeq)); + ON_CALL(*backend_, fetchLedgerDiff(kSeq - 1, _)).WillByDefault(Return(kDiffsForSeqMinuS1)); EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).Times(2); - auto const cursors = provider.getCursors(kSEQ); + auto const cursors = provider.getCursors(kSeq); ASSERT_EQ(cursors.size(), numCursors + 1); - EXPECT_EQ(cursors.front().start, kFIRST_KEY); - EXPECT_EQ(cursors.back().end, kLAST_KEY); + EXPECT_EQ(cursors.front().start, kFirstKey); + EXPECT_EQ(cursors.back().end, kLastKey); } TEST_F(CursorFromDiffProviderTests, NotEnoughDiffs) @@ -93,21 +93,20 @@ TEST_F(CursorFromDiffProviderTests, NotEnoughDiffs) auto const numCursors = 35; auto const provider = etl::impl::CursorFromDiffProvider{backend_, numCursors}; auto const availableDiffs = 10; - backend_->setRange(kSEQ - availableDiffs + 1, kSEQ); + backend_->setRange(kSeq - availableDiffs + 1, kSeq); ON_CALL(*backend_, fetchLedgerDiff(_, _)) .WillByDefault(Return(std::vector{})); - ON_CALL(*backend_, fetchLedgerDiff(kSEQ, _)).WillByDefault(Return(kDIFFS_FOR_SEQ)); - ON_CALL(*backend_, fetchLedgerDiff(kSEQ - 1, _)).WillByDefault(Return(kDIFFS_FOR_SEQ_MINUS1)); + ON_CALL(*backend_, fetchLedgerDiff(kSeq, _)).WillByDefault(Return(kDiffsForSeq)); + ON_CALL(*backend_, fetchLedgerDiff(kSeq - 1, _)).WillByDefault(Return(kDiffsForSeqMinuS1)); EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).Times(availableDiffs); - auto const cursors = provider.getCursors(kSEQ); + auto const cursors = provider.getCursors(kSeq); auto const removed = 2; // lost 2 objects because it is removed. auto const repeated = 1; // repeated 1 object ASSERT_EQ( - cursors.size(), - kDIFFS_FOR_SEQ.size() + kDIFFS_FOR_SEQ_MINUS1.size() - removed - repeated + 1 + cursors.size(), kDiffsForSeq.size() + kDiffsForSeqMinuS1.size() - removed - repeated + 1 ); - EXPECT_EQ(cursors.front().start, kFIRST_KEY); - EXPECT_EQ(cursors.back().end, kLAST_KEY); + EXPECT_EQ(cursors.front().start, kFirstKey); + EXPECT_EQ(cursors.back().end, kLastKey); } diff --git a/tests/unit/etl/CursorFromFixDiffNumProviderTests.cpp b/tests/unit/etl/CursorFromFixDiffNumProviderTests.cpp index 852397961..556521383 100644 --- a/tests/unit/etl/CursorFromFixDiffNumProviderTests.cpp +++ b/tests/unit/etl/CursorFromFixDiffNumProviderTests.cpp @@ -16,7 +16,7 @@ using namespace testing; namespace { -constexpr auto kSEQ = 30; +constexpr auto kSeq = 30; struct CursorProviderTest : util::prometheus::WithPrometheus, MockBackendTestNaggy { DiffProvider diffProvider; @@ -44,11 +44,11 @@ TEST_P(ParametrizedCursorProviderTest, GetCursorsWithDifferentProviderSettings) ON_CALL(*backend_, fetchLedgerDiff(_, _)).WillByDefault(Return(diffs)); EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).Times(numDiffs); - auto const cursors = provider.getCursors(kSEQ); + auto const cursors = provider.getCursors(kSeq); ASSERT_EQ(cursors.size(), diffs.size() + 1); - EXPECT_EQ(cursors.front().start, kFIRST_KEY); - EXPECT_EQ(cursors.back().end, kLAST_KEY); + EXPECT_EQ(cursors.front().start, kFirstKey); + EXPECT_EQ(cursors.back().end, kLastKey); } TEST_F(CursorProviderTest, EmptyCursorIsHandledCorrectly) @@ -59,9 +59,9 @@ TEST_F(CursorProviderTest, EmptyCursorIsHandledCorrectly) ON_CALL(*backend_, fetchLedgerDiff(_, _)).WillByDefault(Return(diffs)); EXPECT_CALL(*backend_, fetchLedgerDiff(_, _)).Times(0); - auto const cursors = provider.getCursors(kSEQ); + auto const cursors = provider.getCursors(kSeq); ASSERT_EQ(cursors.size(), 1); - EXPECT_EQ(cursors.front().start, kFIRST_KEY); - EXPECT_EQ(cursors.back().end, kLAST_KEY); + EXPECT_EQ(cursors.front().start, kFirstKey); + EXPECT_EQ(cursors.back().end, kLastKey); } diff --git a/tests/unit/etl/ETLServiceTests.cpp b/tests/unit/etl/ETLServiceTests.cpp index abf6eb266..3facf6182 100644 --- a/tests/unit/etl/ETLServiceTests.cpp +++ b/tests/unit/etl/ETLServiceTests.cpp @@ -53,8 +53,8 @@ using namespace util::config; namespace { -constinit auto const kSEQ = 100; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 100; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; struct MockMonitor : public etl::MonitorInterface { @@ -152,7 +152,7 @@ struct MockMonitorProvider : etl::MonitorProviderInterface { auto createTestData(uint32_t seq) { - auto const header = createLedgerHeader(kLEDGER_HASH, seq); + auto const header = createLedgerHeader(kLedgerHash, seq); return etl::model::LedgerData{ .transactions = {}, .objects = {util::createObject(), util::createObject(), util::createObject()}, @@ -305,29 +305,29 @@ TEST_F(ETLServiceTests, RunWithEmptyDatabase) { auto mockTaskManager = std::make_unique>(); auto& mockTaskManagerRef = *mockTaskManager; - auto ledgerData = createTestData(kSEQ); + auto ledgerData = createTestData(kSeq); EXPECT_FALSE(systemState_->etlStarted); testing::Sequence const s; EXPECT_CALL(*backend_, hardFetchLedgerRange) .InSequence(s) .WillOnce(testing::Return(std::nullopt)); - EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSEQ)); - EXPECT_CALL(*extractor_, extractLedgerOnly(kSEQ)).WillOnce(testing::Return(ledgerData)); - EXPECT_CALL(*balancer_, loadInitialLedger(kSEQ, testing::_, testing::_)) + EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSeq)); + EXPECT_CALL(*extractor_, extractLedgerOnly(kSeq)).WillOnce(testing::Return(ledgerData)); + EXPECT_CALL(*balancer_, loadInitialLedger(kSeq, testing::_, testing::_)) .WillOnce(testing::Return(std::vector{})); EXPECT_CALL(*loader_, loadInitialLedger).WillOnce(testing::Return(ripple::LedgerHeader{})); EXPECT_CALL(*backend_, hardFetchLedgerRange) .Times(1) .InSequence(s) - .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); + .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); EXPECT_CALL(mockTaskManagerRef, run); - EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce([&](auto&&...) { EXPECT_TRUE(systemState_->etlStarted); return std::unique_ptr(mockTaskManager.release()); }); - EXPECT_CALL(*monitorProvider_, make(testing::_, testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*monitorProvider_, make(testing::_, testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce([this](auto, auto, auto, auto, auto) { EXPECT_FALSE(systemState_->etlStarted); return std::make_unique>(); @@ -339,16 +339,16 @@ TEST_F(ETLServiceTests, RunWithEmptyDatabase) TEST_F(ETLServiceTests, RunWithPopulatedDatabase) { EXPECT_FALSE(systemState_->etlStarted); - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*monitorProvider_, make(testing::_, testing::_, testing::_, kSEQ + 1, testing::_)) + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*monitorProvider_, make(testing::_, testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce([this](auto, auto, auto, auto, auto) { EXPECT_FALSE(systemState_->etlStarted); return std::make_unique>(); }); - EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); } @@ -356,17 +356,17 @@ TEST_F(ETLServiceTests, RunWithPopulatedDatabase) TEST_F(ETLServiceTests, SyncCacheWithDbBeforeStartingMonitor) { EXPECT_FALSE(systemState_->etlStarted); - backend_->cache().update({}, kSEQ - 2, false); + backend_->cache().update({}, kSeq - 2, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); - EXPECT_CALL(*monitorProvider_, make(testing::_, testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*monitorProvider_, make(testing::_, testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce([this](auto, auto, auto, auto, auto) { EXPECT_FALSE(systemState_->etlStarted); return std::make_unique>(); }); - EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); } @@ -404,19 +404,19 @@ TEST_F(ETLServiceTests, HandlesWriteConflictInMonitorSubscription) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); writeCommandConnection_.disconnect(); systemState_->writeCommandSignal(etl::SystemState::WriteCommand::StopWriting); - EXPECT_CALL(*publisher_, publish(kSEQ + 1, testing::_, testing::_)); + EXPECT_CALL(*publisher_, publish(kSeq + 1, testing::_, testing::_)); ASSERT_TRUE(capturedCallback); - capturedCallback(kSEQ + 1); + capturedCallback(kSeq + 1); EXPECT_FALSE(systemState_->isWriting); } @@ -440,25 +440,25 @@ TEST_F(ETLServiceTests, NormalFlowInMonitorSubscription) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isWriting = false; std::vector const dummyDiff = {}; - EXPECT_CALL(*backend_, fetchLedgerDiff(kSEQ + 1, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerDiff(kSeq + 1, testing::_)) .WillOnce(testing::Return(dummyDiff)); EXPECT_CALL( - *cacheUpdater_, update(kSEQ + 1, testing::A const&>()) + *cacheUpdater_, update(kSeq + 1, testing::A const&>()) ); - EXPECT_CALL(*publisher_, publish(kSEQ + 1, testing::_, testing::_)); + EXPECT_CALL(*publisher_, publish(kSeq + 1, testing::_, testing::_)); ASSERT_TRUE(capturedCallback); - capturedCallback(kSEQ + 1); + capturedCallback(kSeq + 1); } TEST_F(ETLServiceTests, AttemptTakeoverWriter) @@ -484,11 +484,11 @@ TEST_F(ETLServiceTests, AttemptTakeoverWriter) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isStrictReadonly = false; // writer node @@ -498,7 +498,7 @@ TEST_F(ETLServiceTests, AttemptTakeoverWriter) auto& mockTaskManagerRef = *mockTaskManager; EXPECT_CALL(mockTaskManagerRef, run); - EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce(testing::Return(std::move(mockTaskManager))); EXPECT_CALL( @@ -534,21 +534,21 @@ TEST_F(ETLServiceTests, GiveUpWriterAfterWriteConflict) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isWriting = true; writeCommandConnection_.disconnect(); systemState_->writeCommandSignal(etl::SystemState::WriteCommand::StopWriting); - EXPECT_CALL(*publisher_, publish(kSEQ + 1, testing::_, testing::_)); + EXPECT_CALL(*publisher_, publish(kSeq + 1, testing::_, testing::_)); ASSERT_TRUE(capturedCallback); - capturedCallback(kSEQ + 1); + capturedCallback(kSeq + 1); EXPECT_FALSE(systemState_->isWriting); // gives up writing } @@ -556,8 +556,8 @@ TEST_F(ETLServiceTests, GiveUpWriterAfterWriteConflict) TEST_F(ETLServiceTests, CancelledLoadInitialLedger) { EXPECT_CALL(*backend_, hardFetchLedgerRange).WillOnce(testing::Return(std::nullopt)); - EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSEQ)); - EXPECT_CALL(*extractor_, extractLedgerOnly(kSEQ)).WillOnce(testing::Return(std::nullopt)); + EXPECT_CALL(*ledgers_, getMostRecent()).WillRepeatedly(testing::Return(kSeq)); + EXPECT_CALL(*extractor_, extractLedgerOnly(kSeq)).WillOnce(testing::Return(std::nullopt)); // These calls should not happen because loading the initial ledger fails EXPECT_CALL(*balancer_, loadInitialLedger(testing::_, testing::_, testing::_)).Times(0); @@ -572,7 +572,7 @@ TEST_F(ETLServiceTests, WaitForValidatedLedgerIsAbortedLeadToFailToLoadInitialLe testing::Sequence const s; EXPECT_CALL(*backend_, hardFetchLedgerRange).WillOnce(testing::Return(std::nullopt)); EXPECT_CALL(*ledgers_, getMostRecent()).InSequence(s).WillOnce(testing::Return(std::nullopt)); - EXPECT_CALL(*ledgers_, getMostRecent()).InSequence(s).WillOnce(testing::Return(kSEQ)); + EXPECT_CALL(*ledgers_, getMostRecent()).InSequence(s).WillOnce(testing::Return(kSeq)); // No other calls should happen because we exit early EXPECT_CALL(*extractor_, extractLedgerOnly).Times(0); @@ -585,20 +585,20 @@ TEST_F(ETLServiceTests, WaitForValidatedLedgerIsAbortedLeadToFailToLoadInitialLe TEST_F(ETLServiceTests, RunStopsIfInitialLoadIsCancelledByBalancer) { - constexpr uint32_t kMOCK_START_SEQUENCE = 123u; + constexpr uint32_t kMockStartSequence = 123u; systemState_->isStrictReadonly = false; testing::Sequence const s; EXPECT_CALL(*backend_, hardFetchLedgerRange).WillOnce(testing::Return(std::nullopt)); EXPECT_CALL(*ledgers_, getMostRecent) .InSequence(s) - .WillOnce(testing::Return(kMOCK_START_SEQUENCE)); + .WillOnce(testing::Return(kMockStartSequence)); EXPECT_CALL(*ledgers_, getMostRecent) .InSequence(s) - .WillOnce(testing::Return(kMOCK_START_SEQUENCE + 10)); + .WillOnce(testing::Return(kMockStartSequence + 10)); - auto const dummyLedgerData = createTestData(kMOCK_START_SEQUENCE); - EXPECT_CALL(*extractor_, extractLedgerOnly(kMOCK_START_SEQUENCE)) + auto const dummyLedgerData = createTestData(kMockStartSequence); + EXPECT_CALL(*extractor_, extractLedgerOnly(kMockStartSequence)) .WillOnce(testing::Return(dummyLedgerData)); EXPECT_CALL(*balancer_, loadInitialLedger(testing::_, testing::_, testing::_)) .WillOnce(testing::Return(std::unexpected{etl::InitialLedgerLoadError::Cancelled})); @@ -628,11 +628,11 @@ TEST_F(ETLServiceTests, DbStalledDoesNotTriggerSignalWhenStrictReadonly) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isStrictReadonly = true; // strict readonly mode @@ -667,11 +667,11 @@ TEST_F(ETLServiceTests, DbStalledDoesNotTriggerSignalWhenAlreadyWriting) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isStrictReadonly = false; @@ -704,33 +704,33 @@ TEST_F(ETLServiceTests, CacheUpdatesDependOnActualCacheState_WriterMode) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB initially to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isWriting = true; // In writer mode // Simulate cache is behind (e.g., update failed previously) - // Cache latestLedgerSequence returns kSEQ (behind the new seq kSEQ + 1) + // Cache latestLedgerSequence returns kSeq (behind the new seq kSeq + 1) std::vector const emptyObjs = {}; - backend_->cache().update(emptyObjs, kSEQ); // Set cache to kSEQ + backend_->cache().update(emptyObjs, kSeq); // Set cache to kSeq std::vector const dummyDiff = {}; - EXPECT_CALL(*backend_, fetchLedgerDiff(kSEQ + 1, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerDiff(kSeq + 1, testing::_)) .WillOnce(testing::Return(dummyDiff)); // Cache should be updated even though we're in writer mode EXPECT_CALL( - *cacheUpdater_, update(kSEQ + 1, testing::A const&>()) + *cacheUpdater_, update(kSeq + 1, testing::A const&>()) ); - EXPECT_CALL(*publisher_, publish(kSEQ + 1, testing::_, testing::_)); + EXPECT_CALL(*publisher_, publish(kSeq + 1, testing::_, testing::_)); ASSERT_TRUE(capturedCallback); - capturedCallback(kSEQ + 1); + capturedCallback(kSeq + 1); } TEST_F(ETLServiceTests, OnlyCacheUpdatesWhenBackendIsCurrent) @@ -739,7 +739,7 @@ TEST_F(ETLServiceTests, OnlyCacheUpdatesWhenBackendIsCurrent) auto& mockMonitorRef = *mockMonitor; std::function capturedCallback; // Set cache to be in sync with DB initially to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*monitorProvider_, make).WillOnce([&mockMonitor](auto, auto, auto, auto, auto) { return std::move(mockMonitor); @@ -753,28 +753,28 @@ TEST_F(ETLServiceTests, OnlyCacheUpdatesWhenBackendIsCurrent) EXPECT_CALL(mockMonitorRef, run); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isWriting = false; - // Cache is behind (at kSEQ) + // Cache is behind (at kSeq) std::vector const emptyObjs = {}; - backend_->cache().update(emptyObjs, kSEQ); + backend_->cache().update(emptyObjs, kSeq); std::vector const dummyDiff = {}; - EXPECT_CALL(*backend_, fetchLedgerDiff(kSEQ + 1, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerDiff(kSeq + 1, testing::_)) .WillOnce(testing::Return(dummyDiff)); EXPECT_CALL( - *cacheUpdater_, update(kSEQ + 1, testing::A const&>()) + *cacheUpdater_, update(kSeq + 1, testing::A const&>()) ); - EXPECT_CALL(*publisher_, publish(kSEQ + 1, testing::_, testing::_)); + EXPECT_CALL(*publisher_, publish(kSeq + 1, testing::_, testing::_)); ASSERT_TRUE(capturedCallback); - capturedCallback(kSEQ + 1); + capturedCallback(kSeq + 1); } TEST_F(ETLServiceTests, NoUpdatesWhenBothCacheAndBackendAreCurrent) @@ -783,7 +783,7 @@ TEST_F(ETLServiceTests, NoUpdatesWhenBothCacheAndBackendAreCurrent) auto& mockMonitorRef = *mockMonitor; std::function capturedCallback; // Set cache to be in sync with DB initially to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*monitorProvider_, make).WillOnce([&mockMonitor](auto, auto, auto, auto, auto) { return std::move(mockMonitor); @@ -797,15 +797,15 @@ TEST_F(ETLServiceTests, NoUpdatesWhenBothCacheAndBackendAreCurrent) EXPECT_CALL(mockMonitorRef, run); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); - // Cache is current (at kSEQ + 1) + // Cache is current (at kSeq + 1) std::vector const emptyObjs = {}; - backend_->cache().update(emptyObjs, kSEQ + 1); + backend_->cache().update(emptyObjs, kSeq + 1); // Neither should be updated EXPECT_CALL(*backend_, fetchLedgerDiff).Times(0); @@ -814,26 +814,26 @@ TEST_F(ETLServiceTests, NoUpdatesWhenBothCacheAndBackendAreCurrent) ) .Times(0); - EXPECT_CALL(*publisher_, publish(kSEQ + 1, testing::_, testing::_)); + EXPECT_CALL(*publisher_, publish(kSeq + 1, testing::_, testing::_)); ASSERT_TRUE(capturedCallback); - capturedCallback(kSEQ + 1); + capturedCallback(kSeq + 1); } TEST_F(ETLServiceTests, StopWaitsForWriteCommandHandlersToComplete) { auto mockMonitor = std::make_unique>(); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*monitorProvider_, make).WillOnce([&mockMonitor](auto, auto, auto, auto, auto) { return std::move(mockMonitor); }); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isStrictReadonly = false; @@ -843,7 +843,7 @@ TEST_F(ETLServiceTests, StopWaitsForWriteCommandHandlersToComplete) EXPECT_CALL( mockWriteSignalCommandCallback_, Call(etl::SystemState::WriteCommand::StartWriting) ); - EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce(testing::Return(std::move(mockTaskManager))); // Emit a command @@ -878,11 +878,11 @@ TEST_F(ETLServiceTests, WriteConflictIsHandledImmediately_NotDelayed) EXPECT_CALL(mockMonitorRef, run); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isWriting = true; @@ -905,11 +905,11 @@ TEST_F(ETLServiceTests, WriteCommandsAreSerializedOnStrand) }); // Set cache to be in sync with DB to avoid syncCacheWithDb loop - backend_->cache().update({}, kSEQ, false); + backend_->cache().update({}, kSeq, false); EXPECT_CALL(*backend_, hardFetchLedgerRange) - .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); - EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSEQ)); - EXPECT_CALL(*cacheLoader_, load(kSEQ)); + .WillRepeatedly(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSeq})); + EXPECT_CALL(*ledgers_, getMostRecent()).WillOnce(testing::Return(kSeq)); + EXPECT_CALL(*cacheLoader_, load(kSeq)); service_.run(); systemState_->isStrictReadonly = false; @@ -927,7 +927,7 @@ TEST_F(ETLServiceTests, WriteCommandsAreSerializedOnStrand) EXPECT_CALL( mockWriteSignalCommandCallback_, Call(etl::SystemState::WriteCommand::StartWriting) ); - EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce(testing::Return(std::move(mockTaskManager1))); // Then StopWriting @@ -939,7 +939,7 @@ TEST_F(ETLServiceTests, WriteCommandsAreSerializedOnStrand) EXPECT_CALL( mockWriteSignalCommandCallback_, Call(etl::SystemState::WriteCommand::StartWriting) ); - EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSEQ + 1, testing::_)) + EXPECT_CALL(*taskManagerProvider_, make(testing::_, testing::_, kSeq + 1, testing::_)) .WillOnce(testing::Return(std::move(mockTaskManager2))); } diff --git a/tests/unit/etl/ExtractionTests.cpp b/tests/unit/etl/ExtractionTests.cpp index 1f6d70f8a..aa219a3a6 100644 --- a/tests/unit/etl/ExtractionTests.cpp +++ b/tests/unit/etl/ExtractionTests.cpp @@ -25,11 +25,11 @@ #include namespace { -constinit auto const kLEDGER_HASH = +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kLEDGER_HASH2 = +constinit auto const kLedgerHasH2 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constinit auto const kSEQ = 30; +constinit auto const kSeq = 30; } // namespace struct ExtractionModelTests : virtual public ::testing::Test {}; @@ -45,9 +45,9 @@ TEST_F(ExtractionModelTests, LedgerDataCopyableAndEquatable) .successors = std::vector{{.firstBook = "first", .bookBase = "base"}}, .edgeKeys = std::vector{"key1", "key2"}, - .header = createLedgerHeader(kLEDGER_HASH, kSEQ, 1), + .header = createLedgerHeader(kLedgerHash, kSeq, 1), .rawHeader = {1, 2, 3}, - .seq = kSEQ + .seq = kSeq }; auto const second = first; @@ -77,7 +77,7 @@ TEST_F(ExtractionModelTests, LedgerDataCopyableAndEquatable) { auto third = second; third.header = createLedgerHeader( - kLEDGER_HASH2, kSEQ, 100 + kLedgerHasH2, kSeq, 100 ); // Using large age value to avoid flaky test EXPECT_NE(first, third); } @@ -88,7 +88,7 @@ TEST_F(ExtractionModelTests, LedgerDataCopyableAndEquatable) } { auto third = second; - third.seq = kSEQ - 1; + third.seq = kSeq - 1; EXPECT_NE(first, third); } } @@ -188,8 +188,8 @@ TEST_F(ExtractionTests, OneTransaction) original.set_transaction_blob(txRaw); original.set_metadata_blob(metaRaw); - auto res = extractTx(original, kSEQ); - EXPECT_EQ(res.meta.getLgrSeq(), kSEQ); + 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()); @@ -212,11 +212,11 @@ TEST_F(ExtractionTests, MultipleTransactions) *p = original; } - auto res = extractTxs(list.transactions(), kSEQ); + auto res = extractTxs(list.transactions(), kSeq); EXPECT_EQ(res.size(), 10); for (auto const& tx : res) { - EXPECT_EQ(tx.meta.getLgrSeq(), kSEQ); + 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()); @@ -239,8 +239,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::kLAST_KEY)); - EXPECT_EQ(res.successor, uint256ToString(data::kFIRST_KEY)); + EXPECT_EQ(res.predecessor, uint256ToString(data::kLastKey)); + EXPECT_EQ(res.successor, uint256ToString(data::kFirstKey)); EXPECT_EQ(res.type, expected.type); } @@ -292,8 +292,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::kLAST_KEY)); - EXPECT_EQ(obj.successor, uint256ToString(data::kFIRST_KEY)); + EXPECT_EQ(obj.predecessor, uint256ToString(data::kLastKey)); + EXPECT_EQ(obj.successor, uint256ToString(data::kFirstKey)); EXPECT_EQ(obj.type, expected.type); } } @@ -375,15 +375,15 @@ struct ExtractorTests : ExtractionTests { TEST_F(ExtractorTests, ExtractLedgerWithDiffNoResult) { - EXPECT_CALL(*fetcher, fetchDataAndDiff(kSEQ)).WillOnce(testing::Return(std::nullopt)); - auto res = extractor.extractLedgerWithDiff(kSEQ); + 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(kSEQ)).WillOnce(testing::Return(std::nullopt)); - auto res = extractor.extractLedgerOnly(kSEQ); + EXPECT_CALL(*fetcher, fetchData(kSeq)).WillOnce(testing::Return(std::nullopt)); + auto res = extractor.extractLedgerOnly(kSeq); EXPECT_FALSE(res.has_value()); } @@ -391,8 +391,8 @@ TEST_F(ExtractorTests, ExtractLedgerWithDiffWithResult) { auto original = util::createDataAndDiff(); - EXPECT_CALL(*fetcher, fetchDataAndDiff(kSEQ)).WillOnce(testing::Return(original)); - auto res = extractor.extractLedgerWithDiff(kSEQ); + EXPECT_CALL(*fetcher, fetchDataAndDiff(kSeq)).WillOnce(testing::Return(original)); + auto res = extractor.extractLedgerWithDiff(kSeq); EXPECT_TRUE(res.has_value()); // NOLINTBEGIN(bugprone-unchecked-optional-access) @@ -408,8 +408,8 @@ TEST_F(ExtractorTests, ExtractLedgerOnlyWithResult) { auto original = util::createData(); - EXPECT_CALL(*fetcher, fetchData(kSEQ)).WillOnce(testing::Return(original)); - auto res = extractor.extractLedgerOnly(kSEQ); + EXPECT_CALL(*fetcher, fetchData(kSeq)).WillOnce(testing::Return(original)); + auto res = extractor.extractLedgerOnly(kSeq); EXPECT_TRUE(res.has_value()); // NOLINTBEGIN(bugprone-unchecked-optional-access) diff --git a/tests/unit/etl/GrpcSourceTests.cpp b/tests/unit/etl/GrpcSourceTests.cpp index 34d9cab5c..1357a280c 100644 --- a/tests/unit/etl/GrpcSourceTests.cpp +++ b/tests/unit/etl/GrpcSourceTests.cpp @@ -349,7 +349,7 @@ TEST_F(GrpcSourceStopTests, LoadInitialLedgerStopsWhenRequested) TEST_F(GrpcSourceTests, DeadlineIsHandledCorrectly) { - static constexpr auto kDEADLINE = std::chrono::milliseconds{5}; + static constexpr auto kDeadline = std::chrono::milliseconds{5}; uint32_t const sequence = 123u; bool const getObjects = true; @@ -358,7 +358,7 @@ TEST_F(GrpcSourceTests, DeadlineIsHandledCorrectly) std::binary_semaphore sem(0); auto grpcSource = std::make_unique( - "localhost", std::to_string(getXRPLMockPort()), kDEADLINE + "localhost", std::to_string(getXRPLMockPort()), kDeadline ); // Note: this may not be called at all if gRPC cancels before it gets a chance to call the stub @@ -375,7 +375,7 @@ TEST_F(GrpcSourceTests, DeadlineIsHandledCorrectly) auto const [status, response] = grpcSource->fetchLedger(sequence, getObjects, getObjectNeighbors); - ASSERT_FALSE(status.ok()); // timed out after kDEADLINE + ASSERT_FALSE(status.ok()); // timed out after kDeadline sem.release(); // we don't need to hold GetLedger thread any longer grpcSource.reset(); diff --git a/tests/unit/etl/LedgerPublisherTests.cpp b/tests/unit/etl/LedgerPublisherTests.cpp index 90b7ba14a..ce9683eb1 100644 --- a/tests/unit/etl/LedgerPublisherTests.cpp +++ b/tests/unit/etl/LedgerPublisherTests.cpp @@ -27,15 +27,15 @@ using namespace std::chrono; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kSEQ = 30; -constexpr auto kAGE = 800; -constexpr auto kAMOUNT = 100; -constexpr auto kFEE = 3; -constexpr auto kFINAL_BALANCE = 110; -constexpr auto kFINAL_BALANCE2 = 30; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kSeq = 30; +constexpr auto kAge = 800; +constexpr auto kAmount = 100; +constexpr auto kFee = 3; +constexpr auto kFinalBalance = 110; +constexpr auto kFinalBalancE2 = 30; MATCHER_P(ledgerHeaderMatcher, expectedHeader, "Headers match") { @@ -53,19 +53,19 @@ struct ETLLedgerPublisherTest : util::prometheus::WithPrometheus, MockBackendTes TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderSkipDueToAge) { - // Use kAGE (800) which is > MAX_LEDGER_AGE_SECONDS (600) to test skipping - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, kAGE); + // Use kAge (800) which is > MAX_LEDGER_AGE_SECONDS (600) to test skipping + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, kAge); auto dummyState = etl::SystemState{}; auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - backend_->setRange(kSEQ - 1, kSEQ); + backend_->setRange(kSeq - 1, kSeq); publisher.publish(dummyLedgerHeader); // Verify last published sequence is set immediately auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); // Since age > MAX_LEDGER_AGE_SECONDS, these should not be called EXPECT_CALL(*backend_, doFetchLedgerObject).Times(0); @@ -80,28 +80,28 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderSkipDueToAge) TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderWithinAgeLimit) { // Use age 0 which is < MAX_LEDGER_AGE_SECONDS to ensure publishing happens - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, 0); auto dummyState = etl::SystemState{}; auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeq, _)) .WillOnce(Return(std::vector{})); EXPECT_CALL( - *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSEQ - 1, kSEQ), 0) + *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSeq - 1, kSeq), 0) ); EXPECT_CALL(*mockSubscriptionManagerPtr, pubBookChanges); - backend_->setRange(kSEQ - 1, kSEQ); + backend_->setRange(kSeq - 1, kSeq); publisher.publish(dummyLedgerHeader); // Verify last published sequence is set immediately auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); ctx.join(); EXPECT_TRUE(publisher.lastPublishAgeSeconds() <= 1); @@ -111,14 +111,14 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderIsWritingTrue) { auto dummyState = etl::SystemState{}; dummyState.isWriting = true; - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, kAGE); + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, kAge); auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); publisher.publish(dummyLedgerHeader); auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); ctx.join(); @@ -130,28 +130,28 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderInRange) auto dummyState = etl::SystemState{}; dummyState.isWriting = true; - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); // age is 0 + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, 0); // age is 0 auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - backend_->setRange(kSEQ - 1, kSEQ); + backend_->setRange(kSeq - 1, kSeq); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, kAMOUNT, kFEE, kSEQ) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, kAmount, kFee, kSeq) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, kFINAL_BALANCE, kFINAL_BALANCE2) + createPaymentTransactionMetaObject(kAccount, kAccount2, kFinalBalance, kFinalBalancE2) .getSerializer() .peekData(); - t1.ledgerSequence = kSEQ; + t1.ledgerSequence = kSeq; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger) .WillOnce(Return(std::vector{t1})); EXPECT_CALL( - *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSEQ - 1, kSEQ), 1) + *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSeq - 1, kSeq), 1) ); EXPECT_CALL(*mockSubscriptionManagerPtr, pubBookChanges); // mock 1 transaction @@ -161,7 +161,7 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderInRange) auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); ctx.join(); @@ -173,34 +173,34 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderCloseTimeGreaterThanNow) auto dummyState = etl::SystemState{}; dummyState.isWriting = true; - auto dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); + auto dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, 0); auto const nowPlus10 = system_clock::now() + seconds(10); auto const closeTime = - duration_cast(nowPlus10.time_since_epoch()).count() - kRIPPLE_EPOCH_START; + duration_cast(nowPlus10.time_since_epoch()).count() - kRippleEpochStart; dummyLedgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; - backend_->setRange(kSEQ - 1, kSEQ); + backend_->setRange(kSeq - 1, kSeq); auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, kAMOUNT, kFEE, kSEQ) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, kAmount, kFee, kSeq) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, kFINAL_BALANCE, kFINAL_BALANCE2) + createPaymentTransactionMetaObject(kAccount, kAccount2, kFinalBalance, kFinalBalancE2) .getSerializer() .peekData(); - t1.ledgerSequence = kSEQ; + t1.ledgerSequence = kSeq; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeq, _)) .WillOnce(Return(std::vector{t1})); EXPECT_CALL( - *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSEQ - 1, kSEQ), 1) + *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSeq - 1, kSeq), 1) ); EXPECT_CALL(*mockSubscriptionManagerPtr, pubBookChanges); EXPECT_CALL(*mockSubscriptionManagerPtr, pubTransaction); @@ -209,7 +209,7 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderCloseTimeGreaterThanNow) auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); ctx.join(); @@ -221,7 +221,7 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerSeqStopIsTrue) auto dummyState = etl::SystemState{}; auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); publisher.stop(); - EXPECT_FALSE(publisher.publish(kSEQ, {})); + EXPECT_FALSE(publisher.publish(kSeq, {})); } TEST_F(ETLLedgerPublisherTest, PublishLedgerSeqMaxAttempt) @@ -229,12 +229,12 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerSeqMaxAttempt) auto dummyState = etl::SystemState{}; auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - static constexpr auto kMAX_ATTEMPT = 2; + static constexpr auto kMaxAttempt = 2; - LedgerRange const range{.minSequence = kSEQ - 1, .maxSequence = kSEQ - 1}; - EXPECT_CALL(*backend_, hardFetchLedgerRange).Times(kMAX_ATTEMPT).WillRepeatedly(Return(range)); + LedgerRange const range{.minSequence = kSeq - 1, .maxSequence = kSeq - 1}; + EXPECT_CALL(*backend_, hardFetchLedgerRange).Times(kMaxAttempt).WillRepeatedly(Return(range)); - EXPECT_FALSE(publisher.publish(kSEQ, kMAX_ATTEMPT, std::chrono::milliseconds{1})); + EXPECT_FALSE(publisher.publish(kSeq, kMaxAttempt, std::chrono::milliseconds{1})); } TEST_F(ETLLedgerPublisherTest, PublishLedgerSeqStopIsFalse) @@ -242,13 +242,13 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerSeqStopIsFalse) auto dummyState = etl::SystemState{}; auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - LedgerRange const range{.minSequence = kSEQ, .maxSequence = kSEQ}; + LedgerRange const range{.minSequence = kSeq, .maxSequence = kSeq}; EXPECT_CALL(*backend_, hardFetchLedgerRange).WillOnce(Return(range)); - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, kAGE); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillOnce(Return(dummyLedgerHeader)); + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, kAge); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kSeq, _)).WillOnce(Return(dummyLedgerHeader)); - EXPECT_TRUE(publisher.publish(kSEQ, {})); + EXPECT_TRUE(publisher.publish(kSeq, {})); ctx.join(); } @@ -257,40 +257,40 @@ TEST_F(ETLLedgerPublisherTest, PublishMultipleTxInOrder) auto dummyState = etl::SystemState{}; dummyState.isWriting = true; - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); // age is 0 + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, 0); // age is 0 auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - backend_->setRange(kSEQ - 1, kSEQ); + backend_->setRange(kSeq - 1, kSeq); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); // t1 index > t2 index TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, kAMOUNT, kFEE, kSEQ) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, kAmount, kFee, kSeq) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, kFINAL_BALANCE, kFINAL_BALANCE2, 2) + createPaymentTransactionMetaObject(kAccount, kAccount2, kFinalBalance, kFinalBalancE2, 2) .getSerializer() .peekData(); - t1.ledgerSequence = kSEQ; + t1.ledgerSequence = kSeq; t1.date = 1; TransactionAndMetadata t2; - t2.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, kAMOUNT, kFEE, kSEQ) + t2.transaction = createPaymentTransactionObject(kAccount, kAccount2, kAmount, kFee, kSeq) .getSerializer() .peekData(); t2.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, kFINAL_BALANCE, kFINAL_BALANCE2, 1) + createPaymentTransactionMetaObject(kAccount, kAccount2, kFinalBalance, kFinalBalancE2, 1) .getSerializer() .peekData(); - t2.ledgerSequence = kSEQ; + t2.ledgerSequence = kSeq; t2.date = 2; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeq, _)) .WillOnce(Return(std::vector{t1, t2})); EXPECT_CALL( - *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSEQ - 1, kSEQ), 2) + *mockSubscriptionManagerPtr, pubLedger(_, _, fmt::format("{}-{}", kSeq - 1, kSeq), 2) ); EXPECT_CALL(*mockSubscriptionManagerPtr, pubBookChanges); @@ -302,7 +302,7 @@ TEST_F(ETLLedgerPublisherTest, PublishMultipleTxInOrder) auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); ctx.join(); @@ -315,9 +315,9 @@ TEST_F(ETLLedgerPublisherTest, PublishVeryOldLedgerShouldSkip) dummyState.isWriting = true; // Create a ledger header with age (800) greater than MAX_LEDGER_AGE_SECONDS (600) - auto const dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 800); + auto const dummyLedgerHeader = createLedgerHeader(kLedgerHash, kSeq, 800); auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - backend_->setRange(kSEQ - 1, kSEQ); + backend_->setRange(kSeq - 1, kSeq); EXPECT_CALL(*mockSubscriptionManagerPtr, pubLedger).Times(0); EXPECT_CALL(*mockSubscriptionManagerPtr, pubBookChanges).Times(0); @@ -327,7 +327,7 @@ TEST_F(ETLLedgerPublisherTest, PublishVeryOldLedgerShouldSkip) auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ); + EXPECT_EQ(seq.value(), kSeq); ctx.join(); } @@ -337,19 +337,19 @@ TEST_F(ETLLedgerPublisherTest, PublishMultipleLedgersInQuickSuccession) auto dummyState = etl::SystemState{}; dummyState.isWriting = true; - auto const dummyLedgerHeader1 = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); - auto const dummyLedgerHeader2 = createLedgerHeader(kLEDGER_HASH, kSEQ + 1, 0); + auto const dummyLedgerHeader1 = createLedgerHeader(kLedgerHash, kSeq, 0); + auto const dummyLedgerHeader2 = createLedgerHeader(kLedgerHash, kSeq + 1, 0); auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - backend_->setRange(kSEQ - 1, kSEQ + 1); + backend_->setRange(kSeq - 1, kSeq + 1); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ + 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq + 1, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeq, _)) .WillOnce(Return(std::vector{})); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ + 1, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeq + 1, _)) .WillOnce(Return(std::vector{})); Sequence const s; @@ -377,7 +377,7 @@ TEST_F(ETLLedgerPublisherTest, PublishMultipleLedgersInQuickSuccession) auto const seq = publisher.getLastPublishedSequence(); ASSERT_TRUE(seq.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - EXPECT_EQ(seq.value(), kSEQ + 1); + EXPECT_EQ(seq.value(), kSeq + 1); ctx.join(); } diff --git a/tests/unit/etl/LoadBalancerTests.cpp b/tests/unit/etl/LoadBalancerTests.cpp index 7034ea7dc..c331fd1ac 100644 --- a/tests/unit/etl/LoadBalancerTests.cpp +++ b/tests/unit/etl/LoadBalancerTests.cpp @@ -48,7 +48,7 @@ using namespace util::prometheus; namespace { -constinit auto const kTWO_SOURCES_LEDGER_RESPONSE = R"JSON({ +constinit auto const kTwoSourcesLedgerResponse = R"JSON({ "etl_sources": [ { "ip": "127.0.0.1", @@ -63,7 +63,7 @@ constinit auto const kTWO_SOURCES_LEDGER_RESPONSE = R"JSON({ ] })JSON"; -constinit auto const kTHREE_SOURCES_LEDGER_RESPONSE = R"JSON({ +constinit auto const kThreeSourcesLedgerResponse = R"JSON({ "etl_sources": [ { "ip": "127.0.0.1", @@ -156,7 +156,7 @@ protected: StrictMockNetworkValidatedLedgersPtr networkManager_; StrictMockSourceFactory sourceFactory_{2}; boost::asio::io_context ioContext_; - boost::json::value configJson_ = boost::json::parse(kTWO_SOURCES_LEDGER_RESPONSE); + boost::json::value configJson_ = boost::json::parse(kTwoSourcesLedgerResponse); }; TEST_F(LoadBalancerConstructorTests, construct) @@ -429,7 +429,7 @@ struct LoadBalancer3SourcesTests : LoadBalancerConstructorTests { LoadBalancer3SourcesTests() { sourceFactory_.setSourcesNumber(3); - configJson_ = boost::json::parse(kTHREE_SOURCES_LEDGER_RESPONSE); + configJson_ = boost::json::parse(kThreeSourcesLedgerResponse); EXPECT_CALL(sourceFactory_, makeSource).Times(3); EXPECT_CALL(sourceFactory_.sourceAt(0), forwardToRippled) @@ -684,9 +684,7 @@ TEST_F(LoadBalancerForwardToRippledTests, forward) auto loadBalancer = makeLoadBalancer(); EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request_, clientIP_, LoadBalancer::kADMIN_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kAdminForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -701,9 +699,7 @@ TEST_F(LoadBalancerForwardToRippledTests, forwardWithXUserHeader) auto loadBalancer = makeLoadBalancer(); EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -718,16 +714,12 @@ TEST_F(LoadBalancerForwardToRippledTests, source0Fails) auto loadBalancer = makeLoadBalancer(); EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(std::unexpected{rpc::ClioError::EtlConnectionError})); EXPECT_CALL( sourceFactory_.sourceAt(1), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -758,9 +750,7 @@ TEST_F(LoadBalancerForwardToRippledPrometheusTests, forwardingCacheEnabled) EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -791,16 +781,12 @@ TEST_F(LoadBalancerForwardToRippledPrometheusTests, source0Fails) EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(std::unexpected{rpc::ClioError::EtlConnectionError})); EXPECT_CALL( sourceFactory_.sourceAt(1), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -826,9 +812,7 @@ TEST_F(LoadBalancerForwardToRippledPrometheusTests, adminRequestAlwaysCacheMiss) EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kADMIN_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kAdminForwardingXUserValue, testing::_) ) .Times(2) .WillRepeatedly(Return(response_)); @@ -885,7 +869,7 @@ INSTANTIATE_TEST_SUITE_P( rpc::ClioError::EtlInvalidResponse } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(LoadBalancerForwardToRippledErrorTests, bothSourcesFail) @@ -894,16 +878,12 @@ TEST_P(LoadBalancerForwardToRippledErrorTests, bothSourcesFail) auto loadBalancer = makeLoadBalancer(); EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(std::unexpected{GetParam().firstSourceError})); EXPECT_CALL( sourceFactory_.sourceAt(1), - forwardToRippled( - request_, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request_, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(std::unexpected{GetParam().secondSourceError})); @@ -924,9 +904,7 @@ TEST_F(LoadBalancerForwardToRippledTests, forwardingCacheEnabled) EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -946,9 +924,7 @@ TEST_F(LoadBalancerForwardToRippledTests, adminRequestBypassesForwardingCache) EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kADMIN_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kAdminForwardingXUserValue, testing::_) ) .Times(2) .WillRepeatedly(Return(response_)); @@ -969,16 +945,12 @@ TEST_F(LoadBalancerForwardToRippledTests, adminResponseNotCachedForSubsequentUse EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kADMIN_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kAdminForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); @@ -1008,16 +980,12 @@ TEST_F(LoadBalancerForwardToRippledTests, onLedgerClosedHookInvalidatesCache) EXPECT_CALL( sourceFactory_.sourceAt(0), - forwardToRippled( - request, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(response_)); EXPECT_CALL( sourceFactory_.sourceAt(1), - forwardToRippled( - request, clientIP_, LoadBalancer::kUSER_FORWARDING_X_USER_VALUE, testing::_ - ) + forwardToRippled(request, clientIP_, LoadBalancer::kUserForwardingXUserValue, testing::_) ) .WillOnce(Return(boost::json::object{})); diff --git a/tests/unit/etl/LoadingTests.cpp b/tests/unit/etl/LoadingTests.cpp index 747aa5746..9926dd4cd 100644 --- a/tests/unit/etl/LoadingTests.cpp +++ b/tests/unit/etl/LoadingTests.cpp @@ -29,9 +29,9 @@ using namespace data; namespace { -constinit auto const kLEDGER_HASH = +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kSEQ = 30; +constinit auto const kSeq = 30; struct MockRegistry : etl::RegistryInterface { MOCK_METHOD( @@ -67,7 +67,7 @@ struct LoadingAssertTest : common::util::WithMockAssert, LoadingTests {}; auto createTestData() { - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return LedgerData{ .transactions = {}, .objects = {util::createObject(), util::createObject(), util::createObject()}, @@ -75,7 +75,7 @@ createTestData() .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -129,9 +129,9 @@ TEST_F(LoadingTests, OnInitialLoadGotMoreObjectsWithKey) auto const data = createTestData(); auto const lastKey = std::make_optional("something"); - EXPECT_CALL(*mockRegistryPtr_, dispatchInitialObjects(kSEQ, data.objects, lastKey->data())); + EXPECT_CALL(*mockRegistryPtr_, dispatchInitialObjects(kSeq, data.objects, lastKey->data())); - loader_.onInitialLoadGotMoreObjects(kSEQ, data.objects, lastKey); + loader_.onInitialLoadGotMoreObjects(kSeq, data.objects, lastKey); } TEST_F(LoadingTests, OnInitialLoadGotMoreObjectsWithoutKey) @@ -139,9 +139,9 @@ TEST_F(LoadingTests, OnInitialLoadGotMoreObjectsWithoutKey) auto const data = createTestData(); auto const lastKey = std::optional{}; - EXPECT_CALL(*mockRegistryPtr_, dispatchInitialObjects(kSEQ, data.objects, std::string{})); + EXPECT_CALL(*mockRegistryPtr_, dispatchInitialObjects(kSeq, data.objects, std::string{})); - loader_.onInitialLoadGotMoreObjects(kSEQ, data.objects, lastKey); + loader_.onInitialLoadGotMoreObjects(kSeq, data.objects, lastKey); } TEST_F(LoadingTests, OnInitialLoadGotMoreObjectsFailure) @@ -149,11 +149,11 @@ TEST_F(LoadingTests, OnInitialLoadGotMoreObjectsFailure) auto const data = createTestData(); auto const lastKey = std::optional{}; - EXPECT_CALL(*mockRegistryPtr_, dispatchInitialObjects(kSEQ, data.objects, std::string{})) + EXPECT_CALL(*mockRegistryPtr_, dispatchInitialObjects(kSeq, data.objects, std::string{})) .WillOnce([](auto, auto, auto) { throw std::runtime_error("some error"); }); EXPECT_CALL(*mockAmendmentBlockHandlerPtr_, notifyAmendmentBlocked()); - loader_.onInitialLoadGotMoreObjects(kSEQ, data.objects, lastKey); + loader_.onInitialLoadGotMoreObjects(kSeq, data.objects, lastKey); } TEST_F(LoadingTests, LoadInitialLedgerFailure) @@ -175,7 +175,7 @@ TEST_F(LoadingTests, LoadInitialLedgerFailure) TEST_F(LoadingAssertTest, LoadInitialLedgerHasDataInDB) { auto const data = createTestData(); - auto const range = LedgerRange{.minSequence = kSEQ - 1, .maxSequence = kSEQ}; + auto const range = LedgerRange{.minSequence = kSeq - 1, .maxSequence = kSeq}; // backend_ leaks due to death test. would be nice to figure out a better solution but for now // we simply don't set expectations and allow the mock to leak diff --git a/tests/unit/etl/MonitorTests.cpp b/tests/unit/etl/MonitorTests.cpp index ef223f378..f88aa5bfb 100644 --- a/tests/unit/etl/MonitorTests.cpp +++ b/tests/unit/etl/MonitorTests.cpp @@ -21,8 +21,8 @@ using namespace etl::impl; using namespace data; namespace { -constexpr auto kSTART_SEQ = 123u; -constexpr auto kNO_NEW_LEDGER_REPORT_DELAY = std::chrono::milliseconds(1u); +constexpr auto kStartSeq = 123u; +constexpr auto kNoNewLedgerReportDelay = std::chrono::milliseconds(1u); } // namespace struct MonitorTests : util::prometheus::WithPrometheus, MockBackendTest { @@ -33,13 +33,13 @@ protected: testing::StrictMock> dbStalledMock_; etl::impl::Monitor monitor_ = - etl::impl::Monitor(ctx_, backend_, ledgers_, kSTART_SEQ, kNO_NEW_LEDGER_REPORT_DELAY); + etl::impl::Monitor(ctx_, backend_, ledgers_, kStartSeq, kNoNewLedgerReportDelay); }; TEST_F(MonitorTests, ConsumesAndNotifiesForAllOutstandingSequencesAtOnce) { uint8_t count = 3; - LedgerRange const range(kSTART_SEQ, kSTART_SEQ + count - 1); + LedgerRange const range(kStartSeq, kStartSeq + count - 1); std::binary_semaphore unblock(0); @@ -58,7 +58,7 @@ TEST_F(MonitorTests, ConsumesAndNotifiesForAllOutstandingSequencesAtOnce) TEST_F(MonitorTests, NotifiesForEachSequence) { uint8_t count = 3; - LedgerRange range(kSTART_SEQ, kSTART_SEQ); + LedgerRange range(kStartSeq, kStartSeq); std::binary_semaphore unblock(0); @@ -80,7 +80,7 @@ TEST_F(MonitorTests, NotifiesForEachSequence) TEST_F(MonitorTests, NotifiesWhenForcedByNewSequenceAvailableFromNetwork) { - LedgerRange const range(kSTART_SEQ, kSTART_SEQ); + LedgerRange const range(kStartSeq, kStartSeq); std::binary_semaphore unblock(0); std::function pusher; @@ -93,13 +93,13 @@ TEST_F(MonitorTests, NotifiesWhenForcedByNewSequenceAvailableFromNetwork) auto subscription = monitor_.subscribeToNewSequence(actionMock_.AsStdFunction()); monitor_.run(std::chrono::seconds{10}); // expected to be force-invoked sooner than in 10 sec - pusher(kSTART_SEQ); // pretend network validated a new ledger + pusher(kStartSeq); // pretend network validated a new ledger unblock.acquire(); } TEST_F(MonitorTests, NotifiesWhenForcedByLedgerLoaded) { - LedgerRange const range(kSTART_SEQ, kSTART_SEQ); + LedgerRange const range(kStartSeq, kStartSeq); std::binary_semaphore unblock(0); EXPECT_CALL(*ledgers_, subscribe(testing::_)); @@ -107,18 +107,18 @@ TEST_F(MonitorTests, NotifiesWhenForcedByLedgerLoaded) EXPECT_CALL(actionMock_, Call).WillOnce([&] { unblock.release(); }); auto subscription = monitor_.subscribeToNewSequence(actionMock_.AsStdFunction()); - monitor_.run(std::chrono::seconds{10}); // expected to be force-invoked sooner than in 10 sec - monitor_.notifySequenceLoaded(kSTART_SEQ); // notify about newly committed ledger + monitor_.run(std::chrono::seconds{10}); // expected to be force-invoked sooner than in 10 sec + monitor_.notifySequenceLoaded(kStartSeq); // notify about newly committed ledger unblock.acquire(); } TEST_F(MonitorTests, ResumesMonitoringFromNextSequenceAfterWriteConflict) { - constexpr uint32_t kCONFLICT_SEQ = 456u; - constexpr uint32_t kEXPECTED_NEXT_SEQ = kCONFLICT_SEQ + 1; + constexpr uint32_t kConflictSeq = 456u; + constexpr uint32_t kExpectedNextSeq = kConflictSeq + 1; - LedgerRange const rangeBeforeConflict(kSTART_SEQ, kSTART_SEQ); - LedgerRange const rangeAfterConflict(kEXPECTED_NEXT_SEQ, kEXPECTED_NEXT_SEQ); + LedgerRange const rangeBeforeConflict(kStartSeq, kStartSeq); + LedgerRange const rangeAfterConflict(kExpectedNextSeq, kExpectedNextSeq); std::binary_semaphore unblock(0); EXPECT_CALL(*ledgers_, subscribe(testing::_)); @@ -131,14 +131,14 @@ TEST_F(MonitorTests, ResumesMonitoringFromNextSequenceAfterWriteConflict) .WillRepeatedly(testing::Return(rangeAfterConflict)); } - EXPECT_CALL(actionMock_, Call(kEXPECTED_NEXT_SEQ)).WillOnce([&](uint32_t seq) { - EXPECT_EQ(seq, kEXPECTED_NEXT_SEQ); + EXPECT_CALL(actionMock_, Call(kExpectedNextSeq)).WillOnce([&](uint32_t seq) { + EXPECT_EQ(seq, kExpectedNextSeq); unblock.release(); }); auto subscription = monitor_.subscribeToNewSequence(actionMock_.AsStdFunction()); monitor_.run(std::chrono::nanoseconds{100}); - monitor_.notifyWriteConflict(kCONFLICT_SEQ); + monitor_.notifyWriteConflict(kConflictSeq); unblock.acquire(); } diff --git a/tests/unit/etl/NFTHelpersTests.cpp b/tests/unit/etl/NFTHelpersTests.cpp index 938cba80e..77ae08f7e 100644 --- a/tests/unit/etl/NFTHelpersTests.cpp +++ b/tests/unit/etl/NFTHelpersTests.cpp @@ -24,15 +24,15 @@ namespace { -constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; -constexpr auto kACCOUNT2 = "rnd1nHuzceyQDqnLH8urWNr4QBKt4v7WVk"; -constexpr auto kNFT_ID = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; -constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; -constexpr auto kOFFER1 = "23F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8"; +constexpr auto kAccount = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; +constexpr auto kAccount2 = "rnd1nHuzceyQDqnLH8urWNr4QBKt4v7WVk"; +constexpr auto kNftId = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; +constexpr auto kNftID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; +constexpr auto kOffer1 = "23F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8"; constexpr auto kTX = "13F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8"; // Page index is a valid nft page for ACCOUNT -constexpr auto kPAGE_INDEX = "E1CD8B79A8BCB52335CD40DE97401B2D60A82872FFFFFFFFFFFFFFFFFFFFFFFF"; -constexpr auto kOFFER_ID = "AA86CBF29770F72FA3FF4A5D9A9FA54D6F399A8E038F72393EF782224865E27F"; +constexpr auto kPageIndex = "E1CD8B79A8BCB52335CD40DE97401B2D60A82872FFFFFFFFFFFFFFFFFFFFFFFF"; +constexpr auto kOfferId = "AA86CBF29770F72FA3FF4A5D9A9FA54D6F399A8E038F72393EF782224865E27F"; } // namespace @@ -92,7 +92,7 @@ protected: TEST_F(NFTHelpersTest, NFTDataFromFailedTx) { - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{}); + auto const tx = createNftModifyTxWithMetadata(kAccount, kNftId, ripple::Blob{}); // Inject a failed result ripple::SerialIter sitMeta(ripple::makeSlice(tx.metadata)); @@ -111,7 +111,7 @@ TEST_F(NFTHelpersTest, NFTDataFromFailedTx) TEST_F(NFTHelpersTest, NotNFTTx) { auto const tx = createOracleSetTxWithMetadata( - kACCOUNT, + kAccount, 1, 123, 1, @@ -119,7 +119,7 @@ TEST_F(NFTHelpersTest, NotNFTTx) createPriceDataSeries( {createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)} ), - kPAGE_INDEX, + kPageIndex, false, kTX ); @@ -139,7 +139,7 @@ TEST_F(NFTHelpersTest, NFTModifyWithURI) std::string const uri("1234567890A"); ripple::Blob const uriBlob(uri.begin(), uri.end()); - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, uriBlob); + auto const tx = createNftModifyTxWithMetadata(kAccount, kNftId, uriBlob); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = @@ -149,48 +149,48 @@ TEST_F(NFTHelpersTest, NFTModifyWithURI) ); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, std::nullopt); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, std::nullopt); } TEST_F(NFTHelpersTest, NFTModifyWithoutURI) { - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{}); + auto const tx = createNftModifyTxWithMetadata(kAccount, kNftId, ripple::Blob{}); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, std::nullopt); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, std::nullopt); } TEST_F(NFTHelpersTest, NFTMintFromModifiedNode) { - auto const tx = createMintNftTxWithMetadata(kACCOUNT, 1, 20, 1, kNFT_ID); + auto const tx = createMintNftTxWithMetadata(kAccount, 1, 20, 1, kNftId); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTMintCantFindNewNFT) { // No NFT added to the page auto const tx = createMintNftTxWithMetadataOfCreatedNode( - kACCOUNT, 1, 20, 1, std::nullopt, std::nullopt, kPAGE_INDEX + kAccount, 1, 20, 1, std::nullopt, std::nullopt, kPageIndex ); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); @@ -207,7 +207,7 @@ TEST_F(NFTHelpersTest, NFTMintFromCreatedNode) std::string const uri("1234567890A"); ripple::Blob const uriBlob(uri.begin(), uri.end()); auto const tx = - createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, uri, kPAGE_INDEX); + createMintNftTxWithMetadataOfCreatedNode(kAccount, 1, 20, 1, kNftId, uri, kPageIndex); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); @@ -215,16 +215,16 @@ TEST_F(NFTHelpersTest, NFTMintFromCreatedNode) auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTMintWithoutUriField) { auto const tx = createMintNftTxWithMetadataOfCreatedNode( - kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX + kAccount, 1, 20, 1, kNftId, std::nullopt, kPageIndex ); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = @@ -233,16 +233,16 @@ TEST_F(NFTHelpersTest, NFTMintWithoutUriField) auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) { auto const tx = createMintNftTxWithMetadataOfCreatedNode( - kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX + kAccount, 1, 20, 1, kNftId, std::nullopt, kPageIndex ); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); @@ -257,23 +257,23 @@ TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) { - auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID); + auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kAccount, kNftId); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[1].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[1].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) { - auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID); + auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kAccount, kNftId); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); @@ -287,42 +287,42 @@ TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromModifiedNode) { - auto const tx = createNftBurnTxWithMetadataOfModifiedNode(kACCOUNT, kNFT_ID); + auto const tx = createNftBurnTxWithMetadataOfModifiedNode(kAccount, kNftId); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTCancelOffer) { auto const tx = createCancelNftOffersTxWithMetadata( - kACCOUNT, 1, 2, std::vector{kNFT_ID, kNFT_ID2} + kAccount, 1, 2, std::vector{kNftId, kNftID2} ); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 2); EXPECT_FALSE(nftDatas); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); - verifyNFTTransactionsData(nftTxs[1], sttx, txMeta, kNFT_ID2); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); + verifyNFTTransactionsData(nftTxs[1], sttx, txMeta, kNftID2); } TEST_F(NFTHelpersTest, NFTCancelOfferContainsDuplicateNFTs) { auto const tx = createCancelNftOffersTxWithMetadata( - kACCOUNT, 1, 2, std::vector{kNFT_ID2, kNFT_ID, kNFT_ID2, kNFT_ID} + kAccount, 1, 2, std::vector{kNftID2, kNftId, kNftID2, kNftId} ); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = @@ -331,8 +331,8 @@ TEST_F(NFTHelpersTest, NFTCancelOfferContainsDuplicateNFTs) EXPECT_EQ(nftTxs.size(), 2); EXPECT_FALSE(nftDatas); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); - verifyNFTTransactionsData(nftTxs[1], sttx, txMeta, kNFT_ID2); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); + verifyNFTTransactionsData(nftTxs[1], sttx, txMeta, kNftID2); } TEST_F(NFTHelpersTest, UniqueNFTDatas) @@ -340,23 +340,23 @@ TEST_F(NFTHelpersTest, UniqueNFTDatas) std::vector nftDatas; auto const generateNFTsData = [](char const* nftID, std::uint32_t txIndex) { - auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 50, nftID, 123, kOFFER1); + auto const tx = createCreateNftOfferTxWithMetadata(kAccount, 1, 50, nftID, 123, kOffer1); ripple::SerialIter s{tx.metadata.data(), tx.metadata.size()}; ripple::STObject meta{s, ripple::sfMetadata}; meta.setFieldU32(ripple::sfTransactionIndex, txIndex); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, meta.getSerializer().peekData()); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); return NFTsData{ripple::uint256(nftID), account, ripple::Blob{}, txMeta}; }; - nftDatas.push_back(generateNFTsData(kNFT_ID, 3)); - nftDatas.push_back(generateNFTsData(kNFT_ID, 1)); - nftDatas.push_back(generateNFTsData(kNFT_ID, 2)); + nftDatas.push_back(generateNFTsData(kNftId, 3)); + nftDatas.push_back(generateNFTsData(kNftId, 1)); + nftDatas.push_back(generateNFTsData(kNftId, 2)); - nftDatas.push_back(generateNFTsData(kNFT_ID2, 4)); - nftDatas.push_back(generateNFTsData(kNFT_ID2, 1)); - nftDatas.push_back(generateNFTsData(kNFT_ID2, 5)); + nftDatas.push_back(generateNFTsData(kNftID2, 4)); + nftDatas.push_back(generateNFTsData(kNftID2, 1)); + nftDatas.push_back(generateNFTsData(kNftID2, 5)); auto const uniqueNFTDatas = etl::getUniqueNFTsDatas(nftDatas); @@ -365,13 +365,13 @@ TEST_F(NFTHelpersTest, UniqueNFTDatas) EXPECT_EQ(uniqueNFTDatas[1].ledgerSequence, 1); EXPECT_EQ(uniqueNFTDatas[0].transactionIndex, 5); EXPECT_EQ(uniqueNFTDatas[1].transactionIndex, 3); - EXPECT_EQ(uniqueNFTDatas[0].tokenID, ripple::uint256(kNFT_ID2)); - EXPECT_EQ(uniqueNFTDatas[1].tokenID, ripple::uint256(kNFT_ID)); + EXPECT_EQ(uniqueNFTDatas[0].tokenID, ripple::uint256(kNftID2)); + EXPECT_EQ(uniqueNFTDatas[1].tokenID, ripple::uint256(kNftId)); } TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) { - auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID); + auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 2, kNftId, kOfferId); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); @@ -379,19 +379,19 @@ TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) EXPECT_EQ(nftTxs.size(), 1); EXPECT_TRUE(nftDatas); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } // The offer id in tx is different from the offer id in deleted node in metadata TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail) { - auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID); + auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 2, kNftId, kOfferId); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); // inject a different offer id - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); EXPECT_THROW( etl::getNFTDataFromTx( @@ -404,7 +404,7 @@ TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode) { auto const tx = createAcceptNftSellerOfferTxWithMetadata( - kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true + kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, true ); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = @@ -413,16 +413,16 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode) EXPECT_EQ(nftTxs.size(), 1); EXPECT_TRUE(nftDatas); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromModifiedNode) { auto const tx = createAcceptNftSellerOfferTxWithMetadata( - kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, false + kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, false ); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); auto const sttx = @@ -431,17 +431,17 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromModifiedNode) EXPECT_EQ(nftTxs.size(), 1); EXPECT_TRUE(nftDatas); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); ASSERT_TRUE(nftDatas.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT); + verifyNFTsData(*nftDatas, sttx, txMeta, kNftId, kAccount); } TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail) { // The only changed nft page is owned by ACCOUNT, thus can't find the new owner auto const tx = createAcceptNftSellerOfferTxWithMetadata( - kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true + kAccount, 1, 2, kNftId, kOfferId, kPageIndex, true ); ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); @@ -456,11 +456,11 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta) { auto const tx = createAcceptNftSellerOfferTxWithMetadata( - kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true + kAccount, 1, 2, kNftId, kOfferId, kPageIndex, true ); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); // inject a different offer id - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); EXPECT_THROW( etl::getNFTDataFromTx( @@ -473,7 +473,7 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode) { auto const tx = createAcceptNftSellerOfferTxWithMetadata( - kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true + kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, true ); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); @@ -489,14 +489,14 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) { auto const tx = createAcceptNftSellerOfferTxWithMetadata( - kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true + kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, true ); ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); // The first node is offer, the second is nft page. Change the offer id to something else txMeta.getNodes()[0] .getField(ripple::sfFinalFields) .downcast() - .setFieldH256(ripple::sfNFTokenID, ripple::uint256(kNFT_ID2)); + .setFieldH256(ripple::sfNFTokenID, ripple::uint256(kNftID2)); EXPECT_THROW( etl::getNFTDataFromTx( @@ -508,7 +508,7 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) TEST_F(NFTHelpersTest, NFTCreateOffer) { - auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, 1, kOFFER_ID); + auto const tx = createCreateNftOfferTxWithMetadata(kAccount, 1, 2, kNftId, 1, kOfferId); ripple::TxMeta const txMeta(ripple::uint256(kTX), 5, tx.metadata); auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); @@ -516,7 +516,7 @@ TEST_F(NFTHelpersTest, NFTCreateOffer) EXPECT_EQ(nftTxs.size(), 1); EXPECT_FALSE(nftDatas); - verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); + verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNftId); } TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) @@ -526,8 +526,8 @@ TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) ripple::Blob const uri1Blob(url1.begin(), url1.end()); ripple::Blob const uri2Blob(url2.begin(), url2.end()); - auto const account = getAccountIdWithString(kACCOUNT); - auto const nftPage = createNftTokenPage({{kNFT_ID, url1}, {kNFT_ID2, url2}}, std::nullopt); + auto const account = getAccountIdWithString(kAccount); + auto const nftPage = createNftTokenPage({{kNftId, url1}, {kNftID2, url2}}, std::nullopt); auto const serializerNftPage = nftPage.getSerializer(); auto const blob = std::string( static_cast(serializerNftPage.getDataPtr()), serializerNftPage.getDataLength() @@ -536,24 +536,24 @@ TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) // key is a token made up from owner's account ID followed by unused (in Clio) value described // here: // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0020-non-fungible-tokens#tokenpage-id-format - constexpr auto kEXTRA_BYTES = "000000000000"; - auto const key = std::string(std::begin(account), std::end(account)) + kEXTRA_BYTES; + constexpr auto kExtraBytes = "000000000000"; + auto const key = std::string(std::begin(account), std::end(account)) + kExtraBytes; - uint32_t constexpr kSEQ{5}; - auto const nftDatas = etl::getNFTDataFromObj(kSEQ, key, blob); + uint32_t constexpr kSeq{5}; + auto const nftDatas = etl::getNFTDataFromObj(kSeq, key, blob); EXPECT_EQ(nftDatas.size(), 2); - EXPECT_EQ(nftDatas[0].tokenID, ripple::uint256(kNFT_ID)); + EXPECT_EQ(nftDatas[0].tokenID, ripple::uint256(kNftId)); EXPECT_EQ(*(nftDatas[0].uri), uri1Blob); // NOLINT(bugprone-unchecked-optional-access) EXPECT_FALSE(nftDatas[0].onlyUriChanged); EXPECT_EQ(nftDatas[0].owner, account); - EXPECT_EQ(nftDatas[0].ledgerSequence, kSEQ); + EXPECT_EQ(nftDatas[0].ledgerSequence, kSeq); EXPECT_FALSE(nftDatas[0].isBurned); - EXPECT_EQ(nftDatas[1].tokenID, ripple::uint256(kNFT_ID2)); + EXPECT_EQ(nftDatas[1].tokenID, ripple::uint256(kNftID2)); EXPECT_EQ(*(nftDatas[1].uri), uri2Blob); // NOLINT(bugprone-unchecked-optional-access) EXPECT_FALSE(nftDatas[1].onlyUriChanged); EXPECT_EQ(nftDatas[1].owner, account); - EXPECT_EQ(nftDatas[1].ledgerSequence, kSEQ); + EXPECT_EQ(nftDatas[1].ledgerSequence, kSeq); EXPECT_FALSE(nftDatas[1].isBurned); } diff --git a/tests/unit/etl/NetworkValidatedLedgersTests.cpp b/tests/unit/etl/NetworkValidatedLedgersTests.cpp index 3e188a943..887434387 100644 --- a/tests/unit/etl/NetworkValidatedLedgersTests.cpp +++ b/tests/unit/etl/NetworkValidatedLedgersTests.cpp @@ -31,9 +31,9 @@ TEST_F(NetworkValidatedLedgersTests, WaitUntilValidatedByNetworkWithoutTimeout) TEST_F(NetworkValidatedLedgersTests, WaitUntilValidatedByNetworkWithTimeout) { - static constexpr auto kTIMEOUT_MILLIS = 10u; + static constexpr auto kTimeoutMillis = 10u; auto awaitable = ctx_.execute([this] { - return ledgers_->waitUntilValidatedByNetwork(123u, kTIMEOUT_MILLIS); + return ledgers_->waitUntilValidatedByNetwork(123u, kTimeoutMillis); }); ledgers_->push(122u); diff --git a/tests/unit/etl/RegistryTests.cpp b/tests/unit/etl/RegistryTests.cpp index 7143f953a..27a3e190a 100644 --- a/tests/unit/etl/RegistryTests.cpp +++ b/tests/unit/etl/RegistryTests.cpp @@ -113,9 +113,9 @@ static_assert(ContainsSpec); namespace { -constinit auto const kLEDGER_HASH = +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kSEQ = 30; +constinit auto const kSeq = 30; struct MockExtLedgerData { MOCK_METHOD(void, onLedgerData, (etl::model::LedgerData const&), (const)); @@ -272,7 +272,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(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extBurn, extOffer); reg.dispatchInitialData( etl::model::LedgerData{ @@ -282,7 +282,7 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForInitialTransaction) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ, + .seq = kSeq, } ); } @@ -301,7 +301,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(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry( state_, extBurn, extOffer ); @@ -313,7 +313,7 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForTransaction) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -329,7 +329,7 @@ TEST_F(RegistryTest, InitialObjectsEmpty) ); // 1 vector passed as is auto reg = Registry(state_, extObj, extObjs); - reg.dispatchInitialObjects(kSEQ, {}, {}); + reg.dispatchInitialObjects(kSeq, {}, {}); } TEST_F(RegistryTest, InitialObjectsDispatched) @@ -344,7 +344,7 @@ TEST_F(RegistryTest, InitialObjectsDispatched) auto reg = Registry(state_, extObj, extObjs); reg.dispatchInitialObjects( - kSEQ, {util::createObject(), util::createObject(), util::createObject()}, {} + kSeq, {util::createObject(), util::createObject(), util::createObject()}, {} ); } @@ -354,7 +354,7 @@ TEST_F(RegistryTest, ObjectsDispatched) EXPECT_CALL(extObj, onObject(testing::_, testing::_)).Times(3); // 3 objects sent - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extObj); reg.dispatch( etl::model::LedgerData{ @@ -364,7 +364,7 @@ TEST_F(RegistryTest, ObjectsDispatched) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -381,7 +381,7 @@ TEST_F(RegistryTest, OnLedgerDataForBatch) EXPECT_CALL(ext, onLedgerData(testing::_)); // 1 batch (dispatch call) - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, ext); reg.dispatch( etl::model::LedgerData{ @@ -391,7 +391,7 @@ TEST_F(RegistryTest, OnLedgerDataForBatch) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -407,7 +407,7 @@ TEST_F(RegistryTest, InitialObjectsCorrectOrderOfHookCalls) auto reg = Registry(state_, extObj, extObjs); reg.dispatchInitialObjects( - kSEQ, {util::createObject(), util::createObject(), util::createObject()}, {} + kSeq, {util::createObject(), util::createObject(), util::createObject()}, {} ); } @@ -426,7 +426,7 @@ TEST_F(RegistryTest, InitialDataCorrectOrderOfHookCalls) EXPECT_CALL(extInitialData, onInitialData); EXPECT_CALL(extInitialTransaction, onInitialTransaction).Times(2); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry( state_, extInitialTransaction, extInitialData ); @@ -438,7 +438,7 @@ TEST_F(RegistryTest, InitialDataCorrectOrderOfHookCalls) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -466,7 +466,7 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls) EXPECT_CALL(extOnTransaction, onTransaction).Times(2); EXPECT_CALL(extOnObject, onObject).Times(3); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry( state_, extOnObject, extOnTransaction, extLedgerData ); @@ -478,7 +478,7 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -495,7 +495,7 @@ TEST_F(RegistryTest, ReadonlyModeLedgerDataAllowed) EXPECT_CALL(ext, onLedgerData(testing::_)); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, ext); reg.dispatch( etl::model::LedgerData{ @@ -505,7 +505,7 @@ TEST_F(RegistryTest, ReadonlyModeLedgerDataAllowed) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -522,7 +522,7 @@ TEST_F(RegistryTest, ReadonlyModeTransactionAllowed) EXPECT_CALL(extTx, onTransaction(testing::_, testing::_)).Times(2); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extTx); reg.dispatch( etl::model::LedgerData{ @@ -532,7 +532,7 @@ TEST_F(RegistryTest, ReadonlyModeTransactionAllowed) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -550,7 +550,7 @@ TEST_F(RegistryTest, ReadonlyModeObjectAllowed) EXPECT_CALL(extObj, onObject(testing::_, testing::_)).Times(3); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extObj); reg.dispatch( etl::model::LedgerData{ @@ -560,7 +560,7 @@ TEST_F(RegistryTest, ReadonlyModeObjectAllowed) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -577,7 +577,7 @@ TEST_F(RegistryTest, ReadonlyModeInitialDataAllowed) EXPECT_CALL(extInitialData, onInitialData(testing::_)); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extInitialData); reg.dispatchInitialData( etl::model::LedgerData{ @@ -587,7 +587,7 @@ TEST_F(RegistryTest, ReadonlyModeInitialDataAllowed) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -604,7 +604,7 @@ TEST_F(RegistryTest, ReadonlyModeInitialTransactionAllowed) EXPECT_CALL(extTx, onInitialTransaction(testing::_, testing::_)).Times(2); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extTx); reg.dispatchInitialData( etl::model::LedgerData{ @@ -614,7 +614,7 @@ TEST_F(RegistryTest, ReadonlyModeInitialTransactionAllowed) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -628,7 +628,7 @@ TEST_F(RegistryTest, ReadonlyModeInitialObjectAllowed) auto reg = Registry(state_, extObj); reg.dispatchInitialObjects( - kSEQ, {util::createObject(), util::createObject(), util::createObject()}, {} + kSeq, {util::createObject(), util::createObject(), util::createObject()}, {} ); } @@ -641,7 +641,7 @@ TEST_F(RegistryTest, ReadonlyModeInitialObjectsAllowed) auto reg = Registry(state_, extObjs); reg.dispatchInitialObjects( - kSEQ, {util::createObject(), util::createObject(), util::createObject()}, {} + kSeq, {util::createObject(), util::createObject(), util::createObject()}, {} ); } @@ -659,7 +659,7 @@ TEST_F(RegistryTest, ReadonlyModeRegularExtensionsNotCalled) EXPECT_CALL(extLedgerData, onLedgerData(testing::_)) .Times(0); // Should NOT be called in readonly mode - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extLedgerData); reg.dispatch( etl::model::LedgerData{ @@ -669,7 +669,7 @@ TEST_F(RegistryTest, ReadonlyModeRegularExtensionsNotCalled) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -690,7 +690,7 @@ TEST_F(RegistryTest, MixedReadonlyAndRegularExtensions) EXPECT_CALL(extRegular, onLedgerData(testing::_)) .Times(0); // Should NOT be called in readonly mode - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, extReadonly, extRegular); reg.dispatch( @@ -701,7 +701,7 @@ TEST_F(RegistryTest, MixedReadonlyAndRegularExtensions) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -728,9 +728,9 @@ TEST_F(RegistryTest, MonitorInterfaceExecution) }; auto monitor = MockMonitor{}; - EXPECT_CALL(monitor, notifySequenceLoaded(kSEQ)).Times(1); + EXPECT_CALL(monitor, notifySequenceLoaded(kSeq)).Times(1); - monitor.notifySequenceLoaded(kSEQ); + monitor.notifySequenceLoaded(kSeq); } TEST_F(RegistryTest, ReadonlyModeWithAllowInReadonlyTest) @@ -750,7 +750,7 @@ TEST_F(RegistryTest, ReadonlyModeWithAllowInReadonlyTest) EXPECT_CALL(ext, onLedgerData(testing::_)).Times(1); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, ext); reg.dispatch( etl::model::LedgerData{ @@ -760,7 +760,7 @@ TEST_F(RegistryTest, ReadonlyModeWithAllowInReadonlyTest) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); } @@ -798,7 +798,7 @@ TEST_F(RegistryTest, ReadonlyModeExecutePluralHooksIfAllowedPaths) EXPECT_CALL(ext, onInitialData(testing::_)).Times(1); EXPECT_CALL(ext, onInitialObjects(testing::_, testing::_, testing::_)).Times(1); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, ext); reg.dispatch( @@ -809,7 +809,7 @@ TEST_F(RegistryTest, ReadonlyModeExecutePluralHooksIfAllowedPaths) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); @@ -821,11 +821,11 @@ TEST_F(RegistryTest, ReadonlyModeExecutePluralHooksIfAllowedPaths) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); - reg.dispatchInitialObjects(kSEQ, objects, {}); + reg.dispatchInitialObjects(kSeq, objects, {}); } TEST_F(RegistryTest, ReadonlyModeExecuteByOneHooksIfAllowedPaths) @@ -865,7 +865,7 @@ TEST_F(RegistryTest, ReadonlyModeExecuteByOneHooksIfAllowedPaths) EXPECT_CALL(ext, onInitialTransaction(testing::_, testing::_)).Times(1); EXPECT_CALL(ext, onInitialObject(testing::_, testing::_)).Times(1); - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); auto reg = Registry(state_, ext); reg.dispatch( @@ -876,7 +876,7 @@ TEST_F(RegistryTest, ReadonlyModeExecuteByOneHooksIfAllowedPaths) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); @@ -888,9 +888,9 @@ TEST_F(RegistryTest, ReadonlyModeExecuteByOneHooksIfAllowedPaths) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq } ); - reg.dispatchInitialObjects(kSEQ, objects, {}); + reg.dispatchInitialObjects(kSeq, objects, {}); } diff --git a/tests/unit/etl/TaskManagerTests.cpp b/tests/unit/etl/TaskManagerTests.cpp index b3a6996ec..d8317fa9b 100644 --- a/tests/unit/etl/TaskManagerTests.cpp +++ b/tests/unit/etl/TaskManagerTests.cpp @@ -29,8 +29,8 @@ using namespace etl::impl; namespace { -constinit auto const kSEQ = 30; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 30; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; struct MockScheduler : etl::SchedulerInterface { @@ -91,14 +91,14 @@ protected: *mockExtractorPtr_, *mockLoaderPtr_, *mockMonitorPtr_, - kSEQ + kSeq }; }; auto createTestData(uint32_t seq) { - auto const header = createLedgerHeader(kLEDGER_HASH, seq); + auto const header = createLedgerHeader(kLedgerHash, seq); return LedgerData{ .transactions = {}, .objects = {util::createObject(), util::createObject(), util::createObject()}, @@ -114,10 +114,10 @@ createTestData(uint32_t seq) TEST_F(TaskManagerTests, LoaderGetsDataIfNextSequenceIsExtracted) { - static constexpr auto kTOTAL = 64uz; - static constexpr auto kEXTRACTORS = 4uz; + static constexpr auto kTotal = 64uz; + static constexpr auto kExtractors = 4uz; - std::atomic_uint32_t seq = kSEQ; + std::atomic_uint32_t seq = kSeq; std::vector loaded; std::binary_semaphore done{0}; @@ -127,40 +127,40 @@ TEST_F(TaskManagerTests, LoaderGetsDataIfNextSequenceIsExtracted) EXPECT_CALL(*mockExtractorPtr_, extractLedgerWithDiff(testing::_)) .WillRepeatedly([](uint32_t seq) -> std::optional { - if (seq > kSEQ + kTOTAL - 1) + if (seq > kSeq + kTotal - 1) return std::nullopt; return createTestData(seq); }); EXPECT_CALL(*mockLoaderPtr_, load(testing::_)) - .Times(kTOTAL) + .Times(kTotal) .WillRepeatedly([&](LedgerData data) -> std::expected { loaded.push_back(data.seq); - if (loaded.size() == kTOTAL) + if (loaded.size() == kTotal) done.release(); return {}; }); - EXPECT_CALL(*mockMonitorPtr_, notifySequenceLoaded(testing::_)).Times(kTOTAL); + EXPECT_CALL(*mockMonitorPtr_, notifySequenceLoaded(testing::_)).Times(kTotal); - taskManager_.run(kEXTRACTORS); + taskManager_.run(kExtractors); done.acquire(); taskManager_.stop(); - EXPECT_EQ(loaded.size(), kTOTAL); + EXPECT_EQ(loaded.size(), kTotal); for (std::size_t i = 0; i < loaded.size(); ++i) - EXPECT_EQ(loaded[i], kSEQ + i); + EXPECT_EQ(loaded[i], kSeq + i); } TEST_F(TaskManagerTests, WriteConflictHandling) { - static constexpr auto kTOTAL = 64uz; - static constexpr auto kCONFLICT_AFTER = 32uz; // Conflict after 32 ledgers - static constexpr auto kEXTRACTORS = 4uz; + static constexpr auto kTotal = 64uz; + static constexpr auto kConflictAfter = 32uz; // Conflict after 32 ledgers + static constexpr auto kExtractors = 4uz; - std::atomic_uint32_t seq = kSEQ; + std::atomic_uint32_t seq = kSeq; std::vector loaded; std::binary_semaphore done{0}; bool conflictOccurred = false; @@ -171,50 +171,50 @@ TEST_F(TaskManagerTests, WriteConflictHandling) EXPECT_CALL(*mockExtractorPtr_, extractLedgerWithDiff(testing::_)) .WillRepeatedly([](uint32_t seq) -> std::optional { - if (seq > kSEQ + kTOTAL - 1) + if (seq > kSeq + kTotal - 1) return std::nullopt; return createTestData(seq); }); - // First kCONFLICT_AFTER calls succeed, then we get a write conflict + // First kConflictAfter calls succeed, then we get a write conflict EXPECT_CALL(*mockLoaderPtr_, load(testing::_)) .WillRepeatedly([&](LedgerData data) -> std::expected { loaded.push_back(data.seq); - if (loaded.size() == kCONFLICT_AFTER) { + if (loaded.size() == kConflictAfter) { conflictOccurred = true; done.release(); return std::unexpected(etl::LoaderError::WriteConflict); } - if (loaded.size() == kTOTAL) + if (loaded.size() == kTotal) done.release(); return {}; }); - EXPECT_CALL(*mockMonitorPtr_, notifySequenceLoaded(testing::_)).Times(kCONFLICT_AFTER - 1); - EXPECT_CALL(*mockMonitorPtr_, notifyWriteConflict(kSEQ + kCONFLICT_AFTER - 1)); + EXPECT_CALL(*mockMonitorPtr_, notifySequenceLoaded(testing::_)).Times(kConflictAfter - 1); + EXPECT_CALL(*mockMonitorPtr_, notifyWriteConflict(kSeq + kConflictAfter - 1)); - taskManager_.run(kEXTRACTORS); + taskManager_.run(kExtractors); done.acquire(); taskManager_.stop(); - EXPECT_EQ(loaded.size(), kCONFLICT_AFTER); + EXPECT_EQ(loaded.size(), kConflictAfter); EXPECT_TRUE(conflictOccurred); for (std::size_t i = 0; i < loaded.size(); ++i) - EXPECT_EQ(loaded[i], kSEQ + i); + EXPECT_EQ(loaded[i], kSeq + i); } TEST_F(TaskManagerTests, AmendmentBlockedHandling) { - static constexpr auto kTOTAL = 64uz; - static constexpr auto kAMENDMENT_BLOCKED_AFTER = 20uz; // Amendment block after 20 ledgers - static constexpr auto kEXTRACTORS = 2uz; + static constexpr auto kTotal = 64uz; + static constexpr auto kAmendmentBlockedAfter = 20uz; // Amendment block after 20 ledgers + static constexpr auto kExtractors = 2uz; - std::atomic_uint32_t seq = kSEQ; + std::atomic_uint32_t seq = kSeq; std::vector loaded; std::binary_semaphore done{0}; bool amendmentBlockedOccurred = false; @@ -225,7 +225,7 @@ TEST_F(TaskManagerTests, AmendmentBlockedHandling) EXPECT_CALL(*mockExtractorPtr_, extractLedgerWithDiff(testing::_)) .WillRepeatedly([](uint32_t seq) -> std::optional { - if (seq > kSEQ + kTOTAL - 1) + if (seq > kSeq + kTotal - 1) return std::nullopt; return createTestData(seq); @@ -235,29 +235,29 @@ TEST_F(TaskManagerTests, AmendmentBlockedHandling) .WillRepeatedly([&](LedgerData data) -> std::expected { loaded.push_back(data.seq); - if (loaded.size() == kAMENDMENT_BLOCKED_AFTER) { + if (loaded.size() == kAmendmentBlockedAfter) { amendmentBlockedOccurred = true; done.release(); return std::unexpected(etl::LoaderError::AmendmentBlocked); } - if (loaded.size() == kTOTAL) + if (loaded.size() == kTotal) done.release(); return {}; }); EXPECT_CALL(*mockMonitorPtr_, notifySequenceLoaded(testing::_)) - .Times(kAMENDMENT_BLOCKED_AFTER - 1); + .Times(kAmendmentBlockedAfter - 1); EXPECT_CALL(*mockMonitorPtr_, notifyWriteConflict(testing::_)).Times(0); - taskManager_.run(kEXTRACTORS); + taskManager_.run(kExtractors); done.acquire(); taskManager_.stop(); - EXPECT_EQ(loaded.size(), kAMENDMENT_BLOCKED_AFTER); + EXPECT_EQ(loaded.size(), kAmendmentBlockedAfter); EXPECT_TRUE(amendmentBlockedOccurred); for (std::size_t i = 0; i < loaded.size(); ++i) - EXPECT_EQ(loaded[i], kSEQ + i); + EXPECT_EQ(loaded[i], kSeq + i); } diff --git a/tests/unit/etl/ext/CacheTests.cpp b/tests/unit/etl/ext/CacheTests.cpp index 8f75b0e9b..2b75f7020 100644 --- a/tests/unit/etl/ext/CacheTests.cpp +++ b/tests/unit/etl/ext/CacheTests.cpp @@ -17,16 +17,16 @@ using namespace etl::impl; using namespace data; namespace { -constinit auto const kSEQ = 123u; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 123u; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kUNUSED_LAST_KEY = "unused"; +constinit auto const kUnusedLastKey = "unused"; auto createTestData() { auto objects = std::vector{util::createObject(), util::createObject(), util::createObject()}; - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return etl::model::LedgerData{ .transactions = {}, .objects = std::move(objects), @@ -34,7 +34,7 @@ createTestData() .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -71,9 +71,9 @@ TEST_F(CacheExtTests, OnInitialObjectsUpdateCache) { auto const objects = std::vector{util::createObject(), util::createObject()}; - EXPECT_CALL(cache_, update(objects, kSEQ)); + EXPECT_CALL(cache_, update(objects, kSeq)); - ext_.onInitialObjects(kSEQ, objects, kUNUSED_LAST_KEY); + ext_.onInitialObjects(kSeq, objects, kUnusedLastKey); } TEST_F(CacheExtTests, AllowInReadonlyReturnsTrue) diff --git a/tests/unit/etl/ext/CoreTests.cpp b/tests/unit/etl/ext/CoreTests.cpp index e11a6bc12..2027c1091 100644 --- a/tests/unit/etl/ext/CoreTests.cpp +++ b/tests/unit/etl/ext/CoreTests.cpp @@ -16,8 +16,8 @@ using namespace etl::impl; using namespace data; namespace { -constinit auto const kSEQ = 123u; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 123u; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; auto @@ -29,7 +29,7 @@ createTestData() util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), }; - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return etl::model::LedgerData{ .transactions = std::move(transactions), .objects = {}, @@ -37,7 +37,7 @@ createTestData() .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -74,16 +74,16 @@ TEST_F(CoreExtTests, OnInitialObjectWritesLedgerObject) { auto const data = util::createObject(); - EXPECT_CALL(*backend_, writeLedgerObject(auto{data.keyRaw}, kSEQ, auto{data.dataRaw})); + EXPECT_CALL(*backend_, writeLedgerObject(auto{data.keyRaw}, kSeq, auto{data.dataRaw})); - ext_.onInitialObject(kSEQ, data); + ext_.onInitialObject(kSeq, data); } TEST_F(CoreExtTests, OnObjectWritesLedgerObject) { auto const data = util::createObject(); - EXPECT_CALL(*backend_, writeLedgerObject(auto{data.keyRaw}, kSEQ, auto{data.dataRaw})); + EXPECT_CALL(*backend_, writeLedgerObject(auto{data.keyRaw}, kSeq, auto{data.dataRaw})); - ext_.onObject(kSEQ, data); + ext_.onObject(kSeq, data); } diff --git a/tests/unit/etl/ext/MPTTests.cpp b/tests/unit/etl/ext/MPTTests.cpp index 39c8859e7..294f75d72 100644 --- a/tests/unit/etl/ext/MPTTests.cpp +++ b/tests/unit/etl/ext/MPTTests.cpp @@ -21,12 +21,12 @@ using namespace testing; namespace { -constinit auto const kSEQ = 123u; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 123u; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kHOLDER_ACCOUNT = "rK1EX542EgA9m948JrJRaEzwLVEhqWvnr9"; +constinit auto const kHolderAccount = "rK1EX542EgA9m948JrJRaEzwLVEhqWvnr9"; -constinit auto const kTXN_HEX = +constinit auto const kTxnHex = "120039220000000024002DBD1A201B002DBDA36840000000000000017321EDECF25C029811CAD07AFD616EB75E3803" "E44D0D59A6826AC25FE3" "4A43626D2D157440244262E760314164843026CE2F100D0BFEB0DD6F75026FEB3F75FCAA943F5C874FF0411BC82A85" @@ -35,7 +35,7 @@ constinit auto const kTXN_HEX = "DE4F9978B8FCD8A50636" "30B5737DA605"; -constinit auto const kTXN_META = +constinit auto const kTxnMeta = "201C00000002F8E311007F562668E165750018E0AE5808C131BAF4C26441D2BCF76F8628774DFDF098B7250BE88114" "CEF330DB51154D8DEE24" "9CC3D6DFD04B91F648EE0115002DBD1817E0AF9FDE4F9978B8FCD8A5063630B5737DA605E1E1E511006425002DBD2F" @@ -50,9 +50,9 @@ constinit auto const kTXN_META = "00000024002DBD1B2D00" "000002624000000005F5E0FE8114CEF330DB51154D8DEE249CC3D6DFD04B91F648EEE1E1F1031000"; -constinit auto const kHASH = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2AEBB3AF7654261B"; -constinit auto const kHASH2 = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2AEBB3AF7654261C"; -constinit auto const kHASH3 = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2AEBB3AF7654261D"; +constinit auto const kHash = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2AEBB3AF7654261B"; +constinit auto const kHash2 = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2AEBB3AF7654261C"; +constinit auto const kHash3 = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2AEBB3AF7654261D"; auto createTestData() @@ -61,14 +61,14 @@ createTestData() util::createTransaction( ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // not AUTHORIZE so will not be written - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), + util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash, kTxnMeta, kTxnHex), util::createTransaction(ripple::TxType::ttAMM_CREATE), // not MPT - will be filtered util::createTransaction( ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // not unique - will be filtered }; - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return etl::model::LedgerData{ .transactions = std::move(transactions), .objects = {}, @@ -76,7 +76,7 @@ createTestData() .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -84,12 +84,12 @@ auto createMultipleHoldersTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH2, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH3, kTXN_META, kTXN_HEX) + util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash, kTxnMeta, kTxnHex), + util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash2, kTxnMeta, kTxnHex), + util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash3, kTxnMeta, kTxnHex) }; - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return etl::model::LedgerData{ .transactions = std::move(transactions), .objects = {}, @@ -97,7 +97,7 @@ createMultipleHoldersTestData() .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -138,7 +138,7 @@ TEST_F(MPTExtTests, OnInitialObjectWritesMPT) EXPECT_EQ(holders.size(), 1); }); - ext_.onInitialObject(kSEQ, data); + ext_.onInitialObject(kSeq, data); } TEST_F(MPTExtTests, OnInitialDataWithMultipleHolders) @@ -149,7 +149,7 @@ TEST_F(MPTExtTests, OnInitialDataWithMultipleHolders) EXPECT_EQ(holders.size(), 3); // Expect all three AUTHORIZE transactions auto const expectedAccount = - rpc::accountFromStringStrict(kHOLDER_ACCOUNT); // Expect all three to be the same + rpc::accountFromStringStrict(kHolderAccount); // Expect all three to be the same EXPECT_TRUE(std::ranges::all_of(holders, [&expectedAccount](auto const& data) { return data.holder == expectedAccount; })); diff --git a/tests/unit/etl/ext/NFTTests.cpp b/tests/unit/etl/ext/NFTTests.cpp index 15308d0ef..a5ce62908 100644 --- a/tests/unit/etl/ext/NFTTests.cpp +++ b/tests/unit/etl/ext/NFTTests.cpp @@ -16,11 +16,11 @@ using namespace etl::impl; using namespace data; namespace { -constinit auto const kSEQ = 123u; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 123u; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constinit auto const kTXN_HEX2 = +constinit auto const kTxnHeX2 = "12001D230606B58324048A8B6F501C50E8EBCD412E6CF9D0C2EB6D38BDE1E1C83406AFCB45437DF39A8B0677A9487E" "501DA2A1BC9A62AAEB2A" "2A70F895587A3FB752514AA03F8C6E7C84864653B8673E0368400000000000001E60134000000000001F09732103B8" @@ -31,7 +31,7 @@ constinit auto const kTXN_HEX2 = "9425204A8491C73B1301" "E34FF9EA7D0F7872702E63616665202D2073616C65E1F1"; -constinit auto const kTXN_META2 = +constinit auto const kTxnMetA2 = "201C00000040F8E51100502505A59E11552ABC2FD74D879BE58489A588838AA2BA59E1E05A48A574226CD8B6CE7799" "8971560B639A808E3B97" "42A25334E5CF68EEDEDE52F54E50F4E63921C9F3C40588E426E6FAEC5A000827104B18F97F9209869C9E9CC33EC2AA" @@ -383,19 +383,19 @@ constinit auto const kTXN_META2 = "C2926F1ADA669262B5D362BFC2DB1417D837CBF382AA37F2D88214246B3E06AB367AB9614566B6F90C718B52A44408" "E1E1F1031000"; -constinit auto const kHASH2 = "D7604B124D5D9C89EC1854A6CBD5A1FFD92502E945411B9C8DE397E7F19A74F8"; +constinit auto const kHash2 = "D7604B124D5D9C89EC1854A6CBD5A1FFD92502E945411B9C8DE397E7F19A74F8"; auto createTestData() { auto transactions = std::vector{ util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN, kHASH2, kTXN_META2, kTXN_HEX2), + util::createTransaction(ripple::TxType::ttNFTOKEN_BURN, kHash2, kTxnMetA2, kTxnHeX2), util::createTransaction(ripple::TxType::ttAMM_CREATE), // not NFT - will be filtered util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), // not unique - will be filtered }; - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return etl::model::LedgerData{ .transactions = std::move(transactions), .objects = {}, @@ -403,7 +403,7 @@ createTestData() .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -444,5 +444,5 @@ TEST_F(NFTExtTests, OnInitialObjectExtractsAndWritesNFTData) EXPECT_CALL(*backend_, writeNFTs).WillOnce([](auto const& nfts) { EXPECT_EQ(nfts.size(), 2); }); - ext_.onInitialObject(kSEQ, data); + ext_.onInitialObject(kSeq, data); } diff --git a/tests/unit/etl/ext/SuccessorTests.cpp b/tests/unit/etl/ext/SuccessorTests.cpp index 183222011..bd8228bec 100644 --- a/tests/unit/etl/ext/SuccessorTests.cpp +++ b/tests/unit/etl/ext/SuccessorTests.cpp @@ -29,8 +29,8 @@ using namespace etl::impl; using namespace data; namespace { -constinit auto const kSEQ = 123u; -constinit auto const kLEDGER_HASH = +constinit auto const kSeq = 123u; +constinit auto const kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; auto @@ -42,7 +42,7 @@ createTestData(std::vector objects) util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), }; - auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const header = createLedgerHeader(kLedgerHash, kSeq); return etl::model::LedgerData{ .transactions = std::move(transactions), .objects = std::move(objects), @@ -50,7 +50,7 @@ createTestData(std::vector objects) .edgeKeys = {}, .header = header, .rawHeader = {}, - .seq = kSEQ + .seq = kSeq }; } @@ -80,7 +80,7 @@ TEST_F(SuccessorExtTests, OnLedgerDataLogicErrorIfCacheIsNotFullButSuccessorsNot auto const data = createTestData({}); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(false)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); EXPECT_THROW(ext_.onLedgerData(data), std::logic_error); } @@ -93,7 +93,7 @@ TEST_F( auto const data = createTestData({}); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ - 1)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq - 1)); EXPECT_THROW(ext_.onLedgerData(data), std::logic_error); } @@ -113,18 +113,18 @@ TEST_F( }); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSEQ - 1)) + EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSeq - 1)) .WillRepeatedly(testing::Return(Blob{'0'})); ext_.onLedgerData(data); @@ -145,20 +145,20 @@ TEST_F( }); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(createdObj.key)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(createdObj.key)) ); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(createdObj.key), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(createdObj.key), kSeq, uint256ToString(data::kLastKey)) ); ext_.onLedgerData(data); @@ -180,24 +180,24 @@ TEST_F( auto const bookBase = getBookBase(createdObj.key); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(createdObj.key)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(createdObj.key)) ); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(createdObj.key), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(createdObj.key), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, get(createdObj.key, kSEQ)).WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(bookBase, kSEQ)) + EXPECT_CALL(cache_, get(createdObj.key, kSeq)).WillRepeatedly(testing::Return(std::nullopt)); + EXPECT_CALL(cache_, getSuccessor(bookBase, kSeq)) .WillRepeatedly(testing::Return(LedgerObject{})); ext_.onLedgerData(data); @@ -220,27 +220,27 @@ TEST_F( [[maybe_unused]] testing::InSequence const inSeq; EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(createdObj.key)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(createdObj.key)) ); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(createdObj.key), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(createdObj.key), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, get(createdObj.key, kSEQ)).WillRepeatedly(testing::Return(data::Blob{'0'})); - EXPECT_CALL(cache_, getSuccessor(bookBase, kSEQ)) + EXPECT_CALL(cache_, get(createdObj.key, kSeq)).WillRepeatedly(testing::Return(data::Blob{'0'})); + EXPECT_CALL(cache_, getSuccessor(bookBase, kSeq)) .WillRepeatedly(testing::Return(LedgerObject{.key = createdObj.key, .blob = {}})); - EXPECT_CALL(*backend_, writeSuccessor(uint256ToString(bookBase), kSEQ, testing::_)); + EXPECT_CALL(*backend_, writeSuccessor(uint256ToString(bookBase), kSeq, testing::_)); ext_.onLedgerData(data); } @@ -264,24 +264,24 @@ TEST_F( [[maybe_unused]] testing::InSequence const inSeq; EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSEQ - 1)) + EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSeq - 1)) .WillOnce(testing::Return(oldCachedObj)); - EXPECT_CALL(cache_, get(deletedObj.key, kSEQ)).WillOnce(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(bookBase, kSEQ)).WillOnce(testing::Return(std::nullopt)); + EXPECT_CALL(cache_, get(deletedObj.key, kSeq)).WillOnce(testing::Return(std::nullopt)); + EXPECT_CALL(cache_, getSuccessor(bookBase, kSeq)).WillOnce(testing::Return(std::nullopt)); EXPECT_CALL( - *backend_, writeSuccessor(uint256ToString(bookBase), kSEQ, uint256ToString(data::kLAST_KEY)) + *backend_, writeSuccessor(uint256ToString(bookBase), kSeq, uint256ToString(data::kLastKey)) ); ext_.onLedgerData(data); @@ -306,25 +306,25 @@ TEST_F( [[maybe_unused]] testing::InSequence const inSeq; EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSEQ - 1)) + EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSeq - 1)) .WillOnce(testing::Return(oldCachedObj)); - EXPECT_CALL(cache_, get(deletedObj.key, kSEQ)).WillOnce(testing::Return(data::Blob{'0'})); - EXPECT_CALL(cache_, getSuccessor(bookBase, kSEQ)) + EXPECT_CALL(cache_, get(deletedObj.key, kSeq)).WillOnce(testing::Return(data::Blob{'0'})); + EXPECT_CALL(cache_, getSuccessor(bookBase, kSeq)) .WillRepeatedly(testing::Return(LedgerObject{.key = deletedObj.key, .blob = {}})); EXPECT_CALL( - *backend_, writeSuccessor(uint256ToString(bookBase), kSEQ, uint256ToString(deletedObj.key)) + *backend_, writeSuccessor(uint256ToString(bookBase), kSeq, uint256ToString(deletedObj.key)) ); ext_.onLedgerData(data); @@ -348,18 +348,18 @@ TEST_F(SuccessorExtTests, OnLedgerDataWithDeletedObjectAndWithCachedPredecessorA }); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSeq)) .WillOnce(testing::Return(data::LedgerObject{.key = predKey, .blob = {}})); - EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSeq)) .WillOnce(testing::Return(data::LedgerObject{.key = succKey, .blob = {}})); EXPECT_CALL( - *backend_, writeSuccessor(uint256ToString(predKey), kSEQ, uint256ToString(createdObj.key)) + *backend_, writeSuccessor(uint256ToString(predKey), kSeq, uint256ToString(createdObj.key)) ); EXPECT_CALL( - *backend_, writeSuccessor(uint256ToString(createdObj.key), kSEQ, uint256ToString(succKey)) + *backend_, writeSuccessor(uint256ToString(createdObj.key), kSeq, uint256ToString(succKey)) ); ext_.onLedgerData(data); @@ -378,14 +378,14 @@ TEST_F(SuccessorExtTests, OnLedgerDataWithCreatedObjectAndIncludedSuccessors) auto const succ = util::createSuccessor(); data.successors = {succ, succ, succ}; - EXPECT_CALL(*backend_, writeSuccessor(auto{succ.bookBase}, kSEQ, auto{succ.firstBook})) + EXPECT_CALL(*backend_, writeSuccessor(auto{succ.bookBase}, kSeq, auto{succ.firstBook})) .Times(data.successors->size()); EXPECT_CALL( - *backend_, writeSuccessor(auto{createdObj.predecessor}, kSEQ, auto{createdObj.keyRaw}) + *backend_, writeSuccessor(auto{createdObj.predecessor}, kSeq, auto{createdObj.keyRaw}) ); EXPECT_CALL( - *backend_, writeSuccessor(auto{createdObj.keyRaw}, kSEQ, auto{createdObj.successor}) + *backend_, writeSuccessor(auto{createdObj.keyRaw}, kSeq, auto{createdObj.successor}) ); ext_.onLedgerData(data); @@ -402,16 +402,16 @@ TEST_F(SuccessorExtTests, OnLedgerDataWithDeletedObjectAndIncludedSuccessorsWith util::createObject(Object::ModType::Modified), }); auto succ = util::createSuccessor(); - succ.firstBook = {}; // empty will be transformed into kLAST_KEY + succ.firstBook = {}; // empty will be transformed into kLastKey data.successors = {succ, succ}; EXPECT_CALL( - *backend_, writeSuccessor(auto{succ.bookBase}, kSEQ, uint256ToString(data::kLAST_KEY)) + *backend_, writeSuccessor(auto{succ.bookBase}, kSeq, uint256ToString(data::kLastKey)) ) .Times(data.successors->size()); EXPECT_CALL( - *backend_, writeSuccessor(auto{deletedObj.predecessor}, kSEQ, auto{deletedObj.successor}) + *backend_, writeSuccessor(auto{deletedObj.predecessor}, kSeq, auto{deletedObj.successor}) ); ext_.onLedgerData(data); @@ -434,7 +434,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor [[maybe_unused]] testing::Sequence const inSeq; EXPECT_CALL(cache_, isFull()).WillOnce(testing::Return(true)); - EXPECT_CALL(cache_, getSuccessor(testing::_, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(testing::_, kSeq)) .Times(3) .InSequence(inSeq) .WillRepeatedly([&](auto&&, auto&&) -> std::optional { @@ -447,17 +447,15 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor }); EXPECT_CALL( - *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(firstKey)) + *backend_, writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(firstKey)) ); EXPECT_CALL( - *backend_, - writeSuccessor(uint256ToString(secondKey), kSEQ, uint256ToString(data::kLAST_KEY)) + *backend_, writeSuccessor(uint256ToString(secondKey), kSeq, uint256ToString(data::kLastKey)) ); // NOLINTBEGIN(bugprone-unchecked-optional-access) for (auto const& key : *data.edgeKeys) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSeq)) .InSequence(inSeq) .WillOnce(testing::Return(std::nullopt)); } @@ -483,7 +481,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF [[maybe_unused]] testing::Sequence const inSeq; EXPECT_CALL(cache_, isFull()).WillOnce(testing::Return(true)); - EXPECT_CALL(cache_, getSuccessor(testing::_, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(testing::_, kSeq)) .Times(3) .InSequence(inSeq) .WillRepeatedly([&](auto&&, auto&&) -> std::optional { @@ -496,20 +494,18 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF }); EXPECT_CALL( - *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(firstKey)) + *backend_, writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(firstKey)) ); EXPECT_CALL( - *backend_, - writeSuccessor(uint256ToString(secondKey), kSEQ, uint256ToString(data::kLAST_KEY)) + *backend_, writeSuccessor(uint256ToString(secondKey), kSeq, uint256ToString(data::kLastKey)) ); // NOLINTBEGIN(bugprone-unchecked-optional-access) for (auto const& key : *data.edgeKeys) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSeq)) .InSequence(inSeq) .WillOnce(testing::Return(data::LedgerObject{.key = firstKey, .blob = {}})); - EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSEQ, uint256ToString(firstKey))); + EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSeq, uint256ToString(firstKey))); } // NOLINTEND(bugprone-unchecked-optional-access) @@ -536,7 +532,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE [[maybe_unused]] testing::Sequence const inSeq; EXPECT_CALL(cache_, isFull()).WillOnce(testing::Return(true)); - EXPECT_CALL(cache_, getSuccessor(testing::_, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(testing::_, kSeq)) .Times(3) .InSequence(inSeq) .WillRepeatedly([&](auto&&, auto&&) -> std::optional { @@ -549,29 +545,27 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE }); EXPECT_CALL( - *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(firstKey)) + *backend_, writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(firstKey)) ); EXPECT_CALL( - *backend_, - writeSuccessor(uint256ToString(secondKey), kSEQ, uint256ToString(data::kLAST_KEY)) + *backend_, writeSuccessor(uint256ToString(secondKey), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, get(bookBase, kSEQ)).WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(bookBase, kSEQ)) + EXPECT_CALL(cache_, get(bookBase, kSeq)).WillRepeatedly(testing::Return(std::nullopt)); + EXPECT_CALL(cache_, getSuccessor(bookBase, kSeq)) .WillRepeatedly( testing::Return(data::LedgerObject{.key = firstKey, .blob = data::Blob{'1'}}) ); EXPECT_CALL( - *backend_, writeSuccessor(uint256ToString(bookBase), kSEQ, testing::_) + *backend_, writeSuccessor(uint256ToString(bookBase), kSeq, testing::_) ); // Called once because firstKey returned repeatedly above // NOLINTBEGIN(bugprone-unchecked-optional-access) for (auto const& key : *data.edgeKeys) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSeq)) .InSequence(inSeq) .WillOnce(testing::Return(data::LedgerObject{.key = firstKey, .blob = {'1'}})); - EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSEQ, uint256ToString(firstKey))) + EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSeq, uint256ToString(firstKey))) .InSequence(inSeq); } // NOLINTEND(bugprone-unchecked-optional-access) @@ -602,11 +596,11 @@ TEST_F(SuccessorExtTests, OnInitialObjectsWithEmptyLastKey) std::string lk = lastKey; for (auto const& obj : data) { if (not lk.empty()) - EXPECT_CALL(*backend_, writeSuccessor(std::move(lk), kSEQ, uint256ToString(obj.key))); + EXPECT_CALL(*backend_, writeSuccessor(std::move(lk), kSeq, uint256ToString(obj.key))); lk = uint256ToString(obj.key); } - ext_.onInitialObjects(kSEQ, data, lastKey); + ext_.onInitialObjects(kSeq, data, lastKey); } TEST_F(SuccessorExtTests, OnInitialObjectsWithNonEmptyLastKey) @@ -633,11 +627,11 @@ TEST_F(SuccessorExtTests, OnInitialObjectsWithNonEmptyLastKey) std::string lk = lastKey; for (auto const& obj : data) { - EXPECT_CALL(*backend_, writeSuccessor(std::move(lk), kSEQ, uint256ToString(obj.key))); + EXPECT_CALL(*backend_, writeSuccessor(std::move(lk), kSeq, uint256ToString(obj.key))); lk = uint256ToString(obj.key); } - ext_.onInitialObjects(kSEQ, data, lastKey); + ext_.onInitialObjects(kSeq, data, lastKey); } struct SuccessorExtAssertTests : common::util::WithMockAssert, SuccessorExtTests {}; @@ -654,18 +648,18 @@ TEST_F(SuccessorExtAssertTests, OnLedgerDataWithDeletedObjectAssertsIfGetDeleted }); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(deletedObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSEQ - 1)) + EXPECT_CALL(cache_, getDeleted(deletedObj.key, kSeq - 1)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CLIO_ASSERT_FAIL({ ext_.onLedgerData(data); }); @@ -687,24 +681,24 @@ TEST_F( auto const bookBase = getBookBase(createdObj.key); EXPECT_CALL(cache_, isFull()).WillRepeatedly(testing::Return(true)); - EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSEQ)); + EXPECT_CALL(cache_, latestLedgerSequence()).WillRepeatedly(testing::Return(kSeq)); - EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getPredecessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); - EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSEQ)) + EXPECT_CALL(cache_, getSuccessor(createdObj.key, kSeq)) .WillRepeatedly(testing::Return(std::nullopt)); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(data::kFIRST_KEY), kSEQ, uint256ToString(createdObj.key)) + writeSuccessor(uint256ToString(data::kFirstKey), kSeq, uint256ToString(createdObj.key)) ); EXPECT_CALL( *backend_, - writeSuccessor(uint256ToString(createdObj.key), kSEQ, uint256ToString(data::kLAST_KEY)) + writeSuccessor(uint256ToString(createdObj.key), kSeq, uint256ToString(data::kLastKey)) ); - EXPECT_CALL(cache_, get(createdObj.key, kSEQ)).WillOnce(testing::Return(data::Blob{'0'})); - EXPECT_CALL(cache_, getSuccessor(bookBase, kSEQ)).WillOnce(testing::Return(std::nullopt)); + EXPECT_CALL(cache_, get(createdObj.key, kSeq)).WillOnce(testing::Return(data::Blob{'0'})); + EXPECT_CALL(cache_, getSuccessor(bookBase, kSeq)).WillOnce(testing::Return(std::nullopt)); EXPECT_CLIO_ASSERT_FAIL({ ext_.onLedgerData(data); }); } diff --git a/tests/unit/feed/BookChangesFeedTests.cpp b/tests/unit/feed/BookChangesFeedTests.cpp index 7731d937b..9f5b12d65 100644 --- a/tests/unit/feed/BookChangesFeedTests.cpp +++ b/tests/unit/feed/BookChangesFeedTests.cpp @@ -15,11 +15,11 @@ using namespace data; namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; } // namespace @@ -31,18 +31,18 @@ TEST_F(FeedBookChangeTest, Pub) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 32); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 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(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + createMetaDataForBookChange(kCurrency, kIssuer, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); - static constexpr auto kBOOK_CHANGE_PUBLISH = + static constexpr auto kBookChangePublish = R"JSON({ "type": "bookChanges", "ledger_index": 32, @@ -62,7 +62,7 @@ TEST_F(FeedBookChangeTest, Pub) ] })JSON"; - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kBOOK_CHANGE_PUBLISH))).Times(1); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kBookChangePublish))).Times(1); testFeedPtr->pub(ledgerHeader, transactions); testFeedPtr->unsub(sessionPtr); diff --git a/tests/unit/feed/ForwardFeedTests.cpp b/tests/unit/feed/ForwardFeedTests.cpp index 676e630dd..0f149f5d3 100644 --- a/tests/unit/feed/ForwardFeedTests.cpp +++ b/tests/unit/feed/ForwardFeedTests.cpp @@ -15,7 +15,7 @@ using namespace util::prometheus; namespace { -constexpr auto kFEED = R"JSON({"test": "test"})JSON"; +constexpr auto kFeed = R"JSON({"test": "test"})JSON"; } // namespace @@ -35,8 +35,8 @@ TEST_F(FeedForwardTest, Pub) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - auto const json = json::parse(kFEED).as_object(); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED))).Times(1); + auto const json = json::parse(kFeed).as_object(); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFeed))).Times(1); testFeedPtr->pub(json); testFeedPtr->unsub(sessionPtr); @@ -51,8 +51,8 @@ TEST_F(FeedForwardTest, AutoDisconnect) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - auto const json = json::parse(kFEED).as_object(); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED))); + auto const json = json::parse(kFeed).as_object(); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFeed))); testFeedPtr->pub(json); slot(sessionPtr.get()); diff --git a/tests/unit/feed/LedgerFeedTests.cpp b/tests/unit/feed/LedgerFeedTests.cpp index f389e74d0..599f4842f 100644 --- a/tests/unit/feed/LedgerFeedTests.cpp +++ b/tests/unit/feed/LedgerFeedTests.cpp @@ -12,7 +12,7 @@ #include namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; } // namespace using namespace feed::impl; @@ -24,7 +24,7 @@ using FeedLedgerTest = FeedBaseTest; TEST_F(FeedLedgerTest, SubPub) { backend_->setRange(10, 30); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -33,7 +33,7 @@ TEST_F(FeedLedgerTest, SubPub) // 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 - static constexpr auto kLEDGER_RESPONSE = + static constexpr auto kLedgerResponse = R"JSON({ "validated_ledgers": "10-30", "ledger_index": 30, @@ -49,12 +49,12 @@ TEST_F(FeedLedgerTest, SubPub) EXPECT_CALL(*mockSessionPtr, onDisconnect); auto res = testFeedPtr->sub(yield, backend_, sessionPtr, networkID); // check the response - EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE)); + EXPECT_EQ(res, json::parse(kLedgerResponse)); }); ioContext.run(); EXPECT_EQ(testFeedPtr->count(), 1); - static constexpr auto kLEDGER_PUB = + static constexpr auto kLedgerPub = R"JSON({ "type": "ledgerClosed", "ledger_index": 31, @@ -69,8 +69,8 @@ TEST_F(FeedLedgerTest, SubPub) })JSON"; // test publish - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kLEDGER_PUB))).Times(1); - auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kLedgerPub))).Times(1); + auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, 31); auto fee2 = ripple::Fees(); fee2.reserve = 10; testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8, networkID); @@ -85,12 +85,12 @@ TEST_F(FeedLedgerTest, SubPub) TEST_F(FeedLedgerTest, AutoDisconnect) { backend_->setRange(10, 30); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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)); - static constexpr auto kLEDGER_RESPONSE = + static constexpr auto kLedgerResponse = R"JSON({ "validated_ledgers": "10-30", "ledger_index": 30, @@ -109,7 +109,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect) util::spawn(ioContext, [this](boost::asio::yield_context yield) { auto res = testFeedPtr->sub(yield, backend_, sessionPtr, networkID); // check the response - EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE)); + EXPECT_EQ(res, json::parse(kLedgerResponse)); }); ioContext.run(); @@ -122,7 +122,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect) EXPECT_EQ(testFeedPtr->count(), 0); - auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); + auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, 31); auto fee2 = ripple::Fees(); fee2.reserve = 10; // no error diff --git a/tests/unit/feed/ProposedTransactionFeedTests.cpp b/tests/unit/feed/ProposedTransactionFeedTests.cpp index 96095caa2..4695ba405 100644 --- a/tests/unit/feed/ProposedTransactionFeedTests.cpp +++ b/tests/unit/feed/ProposedTransactionFeedTests.cpp @@ -17,10 +17,10 @@ namespace { -constexpr auto kACCOUNT1 = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kACCOUNT3 = "r92yNeoiCdwULRbjh6cUBEbD71iHcqe1hE"; -constexpr auto kDUMMY_TRANSACTION = +constexpr auto kAccount1 = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount3 = "r92yNeoiCdwULRbjh6cUBEbD71iHcqe1hE"; +constexpr auto kDummyTransaction = R"JSON({ "transaction": { "Account": "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb", @@ -37,7 +37,7 @@ constexpr auto kDUMMY_TRANSACTION = })JSON"; // Expected v2 format: "transaction" renamed to "tx_json", "hash" moved to top level -constexpr auto kDUMMY_TRANSACTION_V2 = +constexpr auto kDummyTransactionV2 = R"JSON({ "hash": "F44393295DB860C6860769C16F5B23887762F09F87A8D1174E0FCFF9E7247F07", "tx_json": { @@ -67,44 +67,44 @@ TEST_F(FeedProposedTransactionTest, ProposedTransaction) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 0); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransaction) { - auto const account = getAccountIdWithString(kACCOUNT1); + 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(); - auto const accountIdle = getAccountIdWithString(kACCOUNT3); + auto const accountIdle = getAccountIdWithString(kAccount3); EXPECT_CALL(*dynamic_cast(sessionIdle.get()), onDisconnect); testFeedPtr->sub(accountIdle, sessionIdle); EXPECT_EQ(testFeedPtr->accountSubCount(), 2); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); // unsub testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, SubStreamAndAccount) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(2); testFeedPtr->sub(account, sessionPtr); @@ -112,48 +112,48 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccount) EXPECT_EQ(testFeedPtr->accountSubCount(), 1); EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))).Times(2); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))).Times(2); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); // unsub testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); // unsub transaction testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 0); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate) { - auto const account = getAccountIdWithString(kACCOUNT1); - auto const account2 = getAccountIdWithString(kACCOUNT2); + 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(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); // unsub account1 testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); // unsub account2 testFeedPtr->unsub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, Count) @@ -164,7 +164,7 @@ TEST_F(FeedProposedTransactionTest, Count) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); - auto const account1 = getAccountIdWithString(kACCOUNT1); + auto const account1 = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account1, sessionPtr); @@ -178,7 +178,7 @@ TEST_F(FeedProposedTransactionTest, Count) testFeedPtr->sub(sessionPtr2); EXPECT_EQ(testFeedPtr->transactionSubcount(), 2); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account2 = getAccountIdWithString(kAccount2); EXPECT_CALL(*dynamic_cast(sessionPtr2.get()), onDisconnect); testFeedPtr->sub(account2, sessionPtr2); @@ -215,7 +215,7 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); - auto const account1 = getAccountIdWithString(kACCOUNT1); + auto const account1 = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account1, sessionPtr); @@ -234,7 +234,7 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect) testFeedPtr->sub(sessionPtr2); EXPECT_EQ(testFeedPtr->transactionSubcount(), 2); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account2 = getAccountIdWithString(kAccount2); EXPECT_CALL(*mockSessionPtr2, onDisconnect); testFeedPtr->sub(account2, sessionPtr2); @@ -263,26 +263,26 @@ TEST_F(FeedProposedTransactionTest, ProposedTransactionV2) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION_V2))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); testFeedPtr->unsub(sessionPtr); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionV2) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2u)); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION_V2))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); testFeedPtr->unsub(account, sessionPtr); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, MixedVersionSubscribers) @@ -297,15 +297,15 @@ TEST_F(FeedProposedTransactionTest, MixedVersionSubscribers) EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1u)); EXPECT_CALL(*mockSessionV2Ptr, apiSubversion).WillOnce(testing::Return(2u)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - EXPECT_CALL(*mockSessionV2Ptr, send(sharedStringJsonEq(kDUMMY_TRANSACTION_V2))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); + EXPECT_CALL(*mockSessionV2Ptr, send(sharedStringJsonEq(kDummyTransactionV2))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicateV2) { - auto const account = getAccountIdWithString(kACCOUNT1); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount1); + auto const account2 = getAccountIdWithString(kAccount2); EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(2); testFeedPtr->sub(account, sessionPtr); @@ -313,13 +313,13 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicateV2) // Both accounts are affected; v2 subscriber should receive the message only once (dedup) EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2u)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION_V2))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, SubStreamAndAccountV2) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(2); testFeedPtr->sub(account, sessionPtr); @@ -327,8 +327,8 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccountV2) // Subscribed to both stream and account: receives message twice (matches v1 behaviour) EXPECT_CALL(*mockSessionPtr, apiSubversion).WillRepeatedly(testing::Return(2u)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION_V2))).Times(2); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))).Times(2); + testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); } struct ProposedTransactionFeedMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture { @@ -355,7 +355,7 @@ TEST_F(ProposedTransactionFeedMockPrometheusTest, subUnsub) testFeedPtr_->sub(sessionPtr_); testFeedPtr_->unsub(sessionPtr_); - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr_, onDisconnect); testFeedPtr_->sub(account, sessionPtr_); testFeedPtr_->unsub(account, sessionPtr_); @@ -380,7 +380,7 @@ TEST_F(ProposedTransactionFeedMockPrometheusTest, AutoDisconnect) }); testFeedPtr_->sub(sessionPtr_); - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr_, onDisconnect).WillOnce([&sessionOnDisconnectSlots](auto slot) { sessionOnDisconnectSlots.push_back(slot); }); diff --git a/tests/unit/feed/SingleFeedBaseTests.cpp b/tests/unit/feed/SingleFeedBaseTests.cpp index e30dba2f2..cc365ddac 100644 --- a/tests/unit/feed/SingleFeedBaseTests.cpp +++ b/tests/unit/feed/SingleFeedBaseTests.cpp @@ -13,7 +13,7 @@ #include namespace { -constexpr auto kFEED = R"JSON({"test": "test"})JSON"; +constexpr auto kFeed = R"JSON({"test": "test"})JSON"; } // namespace using namespace feed::impl; @@ -64,24 +64,24 @@ using SingleFeedBaseTest = FeedBaseTest; TEST_F(SingleFeedBaseTest, Test) { EXPECT_CALL(*mockSessionPtr, onDisconnect); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFeed))); testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - testFeedPtr->pub(kFEED); + testFeedPtr->pub(kFeed); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 0); - testFeedPtr->pub(kFEED); + 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(kFEED))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFeed))); testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - testFeedPtr->pub(kFEED); + testFeedPtr->pub(kFeed); slot(sessionPtr.get()); sessionPtr.reset(); diff --git a/tests/unit/feed/SubscriptionManagerTests.cpp b/tests/unit/feed/SubscriptionManagerTests.cpp index 328bdb9c4..1f0709940 100644 --- a/tests/unit/feed/SubscriptionManagerTests.cpp +++ b/tests/unit/feed/SubscriptionManagerTests.cpp @@ -31,11 +31,11 @@ namespace { -constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; } // namespace @@ -78,13 +78,13 @@ TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtx) EXPECT_CALL(*sessionPtr_, onDisconnect); subscriptionManagerPtr_->subValidation(session_); - static constexpr auto kJSON_MANIFEST = R"JSON({"manifest": "test"})JSON"; - static constexpr auto kJSON_VALIDATION = R"JSON({"validation": "test"})JSON"; + static constexpr auto kJsonManifest = R"JSON({"manifest": "test"})JSON"; + static constexpr auto kJsonValidation = R"JSON({"validation": "test"})JSON"; EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(testing::AtMost(2)); - subscriptionManagerPtr_->forwardManifest(json::parse(kJSON_MANIFEST).get_object()); - subscriptionManagerPtr_->forwardValidation(json::parse(kJSON_VALIDATION).get_object()); + subscriptionManagerPtr_->forwardManifest(json::parse(kJsonManifest).get_object()); + subscriptionManagerPtr_->forwardValidation(json::parse(kJsonValidation).get_object()); } TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly) @@ -107,7 +107,7 @@ TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly) TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) { - static constexpr auto kREPORT_RETURN = + static constexpr auto kReportReturn = R"JSON({ "ledger": 0, "transactions": 2, @@ -145,16 +145,16 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) subscriptionManagerPtr_->subTransactions(session2); subscriptionManagerPtr_->subValidation(session1); subscriptionManagerPtr_->subValidation(session2); - auto const account = getAccountIdWithString(kACCOUNT1); + 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); + auto const issue1 = getIssue(kCurrency, kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; subscriptionManagerPtr_->subBook(book, session1); subscriptionManagerPtr_->subBook(book, session2); - EXPECT_EQ(subscriptionManagerPtr_->report(), json::parse(kREPORT_RETURN)); + EXPECT_EQ(subscriptionManagerPtr_->report(), json::parse(kReportReturn)); // count down when unsub manually subscriptionManagerPtr_->unsubBookChanges(session1); @@ -167,7 +167,7 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) subscriptionManagerPtr_->unsubBook(book, session1); // try to unsub an account which is not subscribed - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account2 = getAccountIdWithString(kAccount2); subscriptionManagerPtr_->unsubAccount(account2, session1); subscriptionManagerPtr_->unsubProposedAccount(account2, session1); auto checkResult = [](json::object reportReturn, int result) { @@ -192,28 +192,28 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) TEST_F(SubscriptionManagerTest, ManifestTest) { - static constexpr auto kDUMMY_MANIFEST = R"JSON({"manifest": "test"})JSON"; + static constexpr auto kDummyManifest = R"JSON({"manifest": "test"})JSON"; EXPECT_CALL(*sessionPtr_, onDisconnect); - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_MANIFEST))); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummyManifest))); subscriptionManagerPtr_->subManifest(session_); - subscriptionManagerPtr_->forwardManifest(json::parse(kDUMMY_MANIFEST).get_object()); + subscriptionManagerPtr_->forwardManifest(json::parse(kDummyManifest).get_object()); - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_MANIFEST))).Times(0); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummyManifest))).Times(0); subscriptionManagerPtr_->unsubManifest(session_); - subscriptionManagerPtr_->forwardManifest(json::parse(kDUMMY_MANIFEST).get_object()); + subscriptionManagerPtr_->forwardManifest(json::parse(kDummyManifest).get_object()); } TEST_F(SubscriptionManagerTest, ValidationTest) { - static constexpr auto kDUMMY = R"JSON({"validation": "test"})JSON"; + static constexpr auto kDummy = R"JSON({"validation": "test"})JSON"; EXPECT_CALL(*sessionPtr_, onDisconnect); - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY))); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummy))); subscriptionManagerPtr_->subValidation(session_); - subscriptionManagerPtr_->forwardValidation(json::parse(kDUMMY).get_object()); + subscriptionManagerPtr_->forwardValidation(json::parse(kDummy).get_object()); - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY))).Times(0); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummy))).Times(0); subscriptionManagerPtr_->unsubValidation(session_); - subscriptionManagerPtr_->forwardValidation(json::parse(kDUMMY).get_object()); + subscriptionManagerPtr_->forwardValidation(json::parse(kDummy).get_object()); } TEST_F(SubscriptionManagerTest, BookChangesTest) @@ -222,17 +222,17 @@ TEST_F(SubscriptionManagerTest, BookChangesTest) subscriptionManagerPtr_->subBookChanges(session_); EXPECT_EQ(subscriptionManagerPtr_->report()["book_changes"], 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 32); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 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(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + createMetaDataForBookChange(kCurrency, kIssuer, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); - static constexpr auto kBOOK_CHANGE_PUBLISH = + static constexpr auto kBookChangePublish = R"JSON({ "type": "bookChanges", "ledger_index": 32, @@ -251,7 +251,7 @@ TEST_F(SubscriptionManagerTest, BookChangesTest) } ] })JSON"; - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kBOOK_CHANGE_PUBLISH))); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kBookChangePublish))); subscriptionManagerPtr_->pubBookChanges(ledgerHeader, transactions); @@ -264,7 +264,7 @@ TEST_F(SubscriptionManagerTest, LedgerTest) backend_->setRange(10, 30); subscriptionManagerPtr_->setNetworkID(networkID_); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -273,7 +273,7 @@ TEST_F(SubscriptionManagerTest, LedgerTest) // 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 - static constexpr auto kLEDGER_RESPONSE = + static constexpr auto kLedgerResponse = R"JSON({ "validated_ledgers": "10-30", "ledger_index": 30, @@ -289,16 +289,16 @@ TEST_F(SubscriptionManagerTest, LedgerTest) EXPECT_CALL(*sessionPtr_, onDisconnect); auto const res = subscriptionManagerPtr_->subLedger(yield, session_); // check the response - EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE)); + EXPECT_EQ(res, json::parse(kLedgerResponse)); }); ctx.run(); EXPECT_EQ(subscriptionManagerPtr_->report()["ledger"], 1); // test publish - auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); + auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, 31); auto fee2 = ripple::Fees(); fee2.reserve = 10; - static constexpr auto kLEDGER_PUB = + static constexpr auto kLedgerPub = R"JSON({ "type": "ledgerClosed", "ledger_index": 31, @@ -311,7 +311,7 @@ TEST_F(SubscriptionManagerTest, LedgerTest) "txn_count": 8, "network_id": 123 })JSON"; - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kLEDGER_PUB))); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kLedgerPub))); subscriptionManagerPtr_->pubLedger(ledgerHeader2, fee2, "10-31", 8); // test unsub @@ -321,8 +321,8 @@ TEST_F(SubscriptionManagerTest, LedgerTest) TEST_F(SubscriptionManagerTest, TransactionTest) { - auto const issue1 = getIssue(kCURRENCY, kISSUER); - auto const account = getAccountIdWithString(kISSUER); + auto const issue1 = getIssue(kCurrency, kIssuer); + auto const account = getAccountIdWithString(kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*sessionPtr_, onDisconnect).Times(3); subscriptionManagerPtr_->subBook(book, session_); @@ -332,15 +332,15 @@ TEST_F(SubscriptionManagerTest, TransactionTest) EXPECT_EQ(subscriptionManagerPtr_->report()["transactions"], 1); EXPECT_EQ(subscriptionManagerPtr_->report()["books"], 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + auto obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - auto const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 3, 1, 1, 3); + auto const metaObj = createMetaDataForBookChange(kCurrency, kIssuer, 22, 3, 1, 1, 3); trans1.metadata = metaObj.getSerializer().peekData(); - static constexpr auto kORDERBOOK_PUBLISH = + static constexpr auto kOrderbookPublish = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -393,7 +393,7 @@ 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." })JSON"; - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(3); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kOrderbookPublish))).Times(3); EXPECT_CALL(*sessionPtr_, apiSubversion).Times(3).WillRepeatedly(testing::Return(1)); subscriptionManagerPtr_->pubTransaction(trans1, ledgerHeader); @@ -407,21 +407,21 @@ TEST_F(SubscriptionManagerTest, TransactionTest) TEST_F(SubscriptionManagerTest, ProposedTransactionTest) { - auto const account = getAccountIdWithString(kACCOUNT1); + 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); - static constexpr auto kDUMMY_TRANSACTION = + static constexpr auto kDummyTransaction = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Destination": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun" } })JSON"; - static constexpr auto kORDERBOOK_PUBLISH = + static constexpr auto kOrderbookPublish = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -474,19 +474,19 @@ 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." })JSON"; - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_TRANSACTION))).Times(2); - EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(2); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummyTransaction))).Times(2); + EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kOrderbookPublish))).Times(2); subscriptionManagerPtr_->forwardProposedTransaction( - json::parse(kDUMMY_TRANSACTION).get_object() + json::parse(kDummyTransaction).get_object() ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + auto obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - auto const metaObj = createMetaDataForBookChange(kCURRENCY, kACCOUNT1, 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); @@ -508,13 +508,13 @@ TEST_F(SubscriptionManagerTest, DuplicateResponseSubTxAndProposedTx) EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(2); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + auto obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - auto const metaObj = createMetaDataForBookChange(kCURRENCY, kACCOUNT1, 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); @@ -527,7 +527,7 @@ TEST_F(SubscriptionManagerTest, DuplicateResponseSubTxAndProposedTx) TEST_F(SubscriptionManagerTest, NoDuplicateResponseSubAccountAndProposedAccount) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*sessionPtr_, onDisconnect).Times(3); subscriptionManagerPtr_->subProposedAccount(account, session_); subscriptionManagerPtr_->subAccount(account, session_); @@ -536,13 +536,13 @@ TEST_F(SubscriptionManagerTest, NoDuplicateResponseSubAccountAndProposedAccount) EXPECT_CALL(*sessionPtr_, send(testing::_)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + auto obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - auto const metaObj = createMetaDataForBookChange(kCURRENCY, kACCOUNT1, 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); diff --git a/tests/unit/feed/TransactionFeedTests.cpp b/tests/unit/feed/TransactionFeedTests.cpp index 6a0e4ada1..65e506940 100644 --- a/tests/unit/feed/TransactionFeedTests.cpp +++ b/tests/unit/feed/TransactionFeedTests.cpp @@ -31,18 +31,18 @@ using namespace data; namespace { -constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kTXN_ID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kAMM_ACCOUNT = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs"; -constexpr auto kLPTOKEN_CURRENCY = "037C35306B24AAB7FF90848206E003279AA47090"; -constexpr auto kNETWORK_ID = 0u; -constexpr auto kNFT_MINT_ID = "000B013A95F14B0044F78A264E41713C64B5F89242540EE208C3098E00000D65"; +constexpr auto kAccount1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kTxnId = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kAmmAccount = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs"; +constexpr auto kLptokenCurrency = "037C35306B24AAB7FF90848206E003279AA47090"; +constexpr auto kNetworkId = 0u; +constexpr auto kNftMintId = "000B013A95F14B0044F78A264E41713C64B5F89242540EE208C3098E00000D65"; -constexpr auto kTRAN_V1 = +constexpr auto kTranV1 = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -93,7 +93,7 @@ constexpr auto kTRAN_V1 = "engine_result_message": "The transaction was applied. Only final in a validated ledger." })JSON"; -constexpr auto kTRAN_V2 = +constexpr auto kTranV2 = R"JSON({ "tx_json": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -143,7 +143,7 @@ constexpr auto kTRAN_V2 = "engine_result_message": "The transaction was applied. Only final in a validated ledger." })JSON"; -constexpr auto kNFT_MINT_TRAN_V1 = +constexpr auto kNftMintTranV1 = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -218,21 +218,21 @@ TEST_F(FeedTransactionTest, SubTransactionV1) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); } @@ -242,21 +242,21 @@ TEST_F(FeedTransactionTest, SubTransactionForProposedTx) testFeedPtr->subProposed(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsubProposed(sessionPtr); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubTransactionV2) @@ -265,156 +265,156 @@ TEST_F(FeedTransactionTest, SubTransactionV2) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubAccountV1) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubForProposedAccount) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->subProposed(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsubProposed(account, sessionPtr); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubAccountV2) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubBothTransactionAndAccount) { - auto const account = getAccountIdWithString(kACCOUNT1); + 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(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + 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(kTRAN_V2))).Times(2); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))).Times(2); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubBookV1) { - auto const issue1 = getIssue(kCURRENCY, kISSUER); + auto const issue1 = getIssue(kCurrency, kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(book, sessionPtr); EXPECT_EQ(testFeedPtr->bookSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + auto obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - auto metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 3, 1, 1, 3); + auto metaObj = createMetaDataForBookChange(kCurrency, kIssuer, 22, 3, 1, 1, 3); trans1.metadata = metaObj.getSerializer().peekData(); - static constexpr auto kORDERBOOK_PUBLISH = + static constexpr auto kOrderbookPublish = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -469,14 +469,14 @@ TEST_F(FeedTransactionTest, SubBookV1) })JSON"; EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kOrderbookPublish))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); // trigger by offer cancel meta data - metaObj = createMetaDataForCancelOffer(kCURRENCY, kISSUER, 22, 3, 1); + metaObj = createMetaDataForCancelOffer(kCurrency, kIssuer, 22, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); - static constexpr auto kORDERBOOK_CANCEL_PUBLISH = + static constexpr auto kOrderbookCancelPublish = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -523,11 +523,11 @@ TEST_F(FeedTransactionTest, SubBookV1) })JSON"; EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_CANCEL_PUBLISH))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kOrderbookCancelPublish))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); // trigger by offer create meta data - static constexpr auto kORDERBOOK_CREATE_PUBLISH = + static constexpr auto kOrderbookCreatePublish = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -572,38 +572,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." })JSON"; - metaObj = createMetaDataForCreateOffer(kCURRENCY, kISSUER, 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(kORDERBOOK_CREATE_PUBLISH))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kOrderbookCreatePublish))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(book, sessionPtr); EXPECT_EQ(testFeedPtr->bookSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubBookV2) { - auto const issue1 = getIssue(kCURRENCY, kISSUER); + auto const issue1 = getIssue(kCurrency, kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(book, sessionPtr); EXPECT_EQ(testFeedPtr->bookSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + auto obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - auto const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 3, 1, 1, 3); + auto const metaObj = createMetaDataForBookChange(kCurrency, kIssuer, 22, 3, 1, 1, 3); trans1.metadata = metaObj.getSerializer().peekData(); - static constexpr auto kORDERBOOK_PUBLISH = + static constexpr auto kOrderbookPublish = R"JSON({ "tx_json": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -657,91 +657,91 @@ TEST_F(FeedTransactionTest, SubBookV2) })JSON"; EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kOrderbookPublish))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(book, sessionPtr); EXPECT_EQ(testFeedPtr->bookSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account2 = getAccountIdWithString(kAccount2); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 2); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account2 = getAccountIdWithString(kAccount2); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 2); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion) @@ -754,23 +754,23 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV2))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubRepeat) @@ -795,8 +795,8 @@ TEST_F(FeedTransactionTest, SubRepeat) testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - auto const account = getAccountIdWithString(kACCOUNT1); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount1); + auto const account2 = getAccountIdWithString(kAccount2); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); @@ -816,7 +816,7 @@ TEST_F(FeedTransactionTest, SubRepeat) testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - auto const issue1 = getIssue(kCURRENCY, kISSUER); + auto const issue1 = getIssue(kCurrency, kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr, onDisconnect); @@ -840,10 +840,10 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); ripple::STObject const obj = - createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); + createCreateOfferTransactionObject(kAccount1, 1, 32, kCurrency, kIssuer, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; ripple::STArray const metaArray{0}; @@ -857,22 +857,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{kTXN_ID}); + line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTxnId}); line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); line.setFieldU32(ripple::sfFlags, 0); - auto const issue2 = getIssue(kCURRENCY, kISSUER); + auto const issue2 = getIssue(kCurrency, kIssuer); line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const issueAccount = getAccountIdWithString(kISSUER); + auto const issueAccount = getAccountIdWithString(kIssuer); auto const kk = ripple::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); + ripple::STObject const accountRoot = createAccountRootObject(kIssuer, 0, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); - static constexpr auto kTRANSACTION_FOR_OWNER_FUND = + static constexpr auto kTransactionForOwnerFund = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -908,7 +908,7 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund) })JSON"; EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRANSACTION_FOR_OWNER_FUND))).Times(1); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTransactionForOwnerFund))).Times(1); EXPECT_CALL( *mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_) @@ -918,7 +918,7 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund) isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_) ) .WillByDefault(testing::Return(false)); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, PublishesNFTokenMintTx) @@ -926,23 +926,23 @@ TEST_F(FeedTransactionTest, PublishesNFTokenMintTx) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); // Creates an NFTokenMint transaction - auto const trans = createMintNftTxWithMetadata(kACCOUNT1, 1, 12, 123, kNFT_MINT_ID); + auto const trans = createMintNftTxWithMetadata(kAccount1, 1, 12, 123, kNftMintId); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kNFT_MINT_TRAN_V1))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kNftMintTranV1))); - testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } -static constexpr auto kTRAN_FROZEN = +static constexpr auto kTranFrozen = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -982,10 +982,10 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); ripple::STObject const obj = - createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); + createCreateOfferTransactionObject(kAccount1, 1, 32, kCurrency, kIssuer, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; ripple::STArray const metaArray{0}; @@ -999,23 +999,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{kTXN_ID}); + line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTxnId}); line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100)); + line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCurrency, kIssuer), 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const issueAccount = getAccountIdWithString(kISSUER); + auto const issueAccount = getAccountIdWithString(kIssuer); auto const kk = ripple::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); + ripple::STObject const accountRoot = createAccountRootObject(kIssuer, 0, 1, 10, 2, kTxnId, 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(kTRAN_FROZEN))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranFrozen))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen) @@ -1023,10 +1023,10 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); ripple::STObject const obj = - createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); + createCreateOfferTransactionObject(kAccount1, 1, 32, kCurrency, kIssuer, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; ripple::STArray const metaArray{0}; @@ -1040,29 +1040,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{kTXN_ID}); + line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTxnId}); line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze); - auto const issueAccount = getAccountIdWithString(kISSUER); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100)); + auto const issueAccount = getAccountIdWithString(kIssuer); + line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCurrency, kIssuer), 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const kk = ripple::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); ripple::STObject const accountRoot = - createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + createAccountRootObject(kIssuer, ripple::lsfGlobalFreeze, 1, 10, 2, kTxnId, 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(kTRAN_FROZEN))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranFrozen))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(account, sessionPtr); @@ -1071,24 +1071,24 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount) testFeedPtr->subProposed(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(account, sessionPtr); testFeedPtr->unsubProposed(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubBothProposedAndValidated) @@ -1100,22 +1100,22 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidated) testFeedPtr->subProposed(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + 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(kTRAN_V1))).Times(2); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))).Times(2); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); testFeedPtr->unsubProposed(sessionPtr); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubProposedDisconnect) @@ -1124,46 +1124,46 @@ TEST_F(FeedTransactionTest, SubProposedDisconnect) testFeedPtr->subProposed(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); sessionPtr.reset(); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, SubProposedAccountDisconnect) { - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->subProposed(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount1, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) + trans1.metadata = createPaymentTransactionMetaObject(kAccount1, kAccount2, 110, 30, 22) .getSerializer() .peekData(); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTranV1))).Times(1); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); sessionPtr.reset(); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } // This test exercises `accountHold` for amendment fixFrozenLPTokenTransfer, so that the output @@ -1173,10 +1173,10 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); ripple::STObject const obj = - createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 1, 3); + createCreateOfferTransactionObject(kAccount1, 1, 32, kLptokenCurrency, kAmmAccount, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; ripple::STArray const metaArray{0}; @@ -1190,10 +1190,10 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) 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{kTXN_ID}); + line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTxnId}); line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); line.setFieldU32(ripple::sfFlags, 0); - auto const issue2 = getIssue(kLPTOKEN_CURRENCY, kAMM_ACCOUNT); + auto const issue2 = getIssue(kLptokenCurrency, kAmmAccount); line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100)); EXPECT_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) @@ -1203,15 +1203,15 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) auto const ammID = ripple::uint256{54321}; // create an amm account because in `accountHolds` checks for the ammID - auto const ammAccount = getAccountIdWithString(kAMM_ACCOUNT); + auto const ammAccount = getAccountIdWithString(kAmmAccount); auto const kk = ripple::keylet::account(ammAccount).key; ripple::STObject const ammAccountRoot = - createAccountRootObject(kAMM_ACCOUNT, 0, 1, 10, 2, kTXN_ID, 3, 0, ammID); + createAccountRootObject(kAmmAccount, 0, 1, 10, 2, kTxnId, 3, 0, ammID); EXPECT_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .Times(2) .WillRepeatedly(testing::Return(ammAccountRoot.getSerializer().peekData())); - static constexpr auto kTRANSACTION_FOR_OWNER_FUND = + static constexpr auto kTransactionForOwnerFund = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -1247,7 +1247,7 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) })JSON"; EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRANSACTION_FOR_OWNER_FUND))).Times(1); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTransactionForOwnerFund))).Times(1); EXPECT_CALL( *mockAmendmentCenterPtr_, @@ -1256,7 +1256,7 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) .WillOnce(testing::Return(true)); auto const ammObj = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), kCURRENCY, kISSUER + kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), kCurrency, kIssuer ); EXPECT_CALL( *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) @@ -1264,21 +1264,21 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) .WillOnce(testing::Return(ammObj.getSerializer().peekData())); // create the issuer account that enacted global freeze - auto const issuerAccount = getAccountIdWithString(kISSUER); + auto const issuerAccount = getAccountIdWithString(kIssuer); ripple::STObject const issuerAccountRoot = - createAccountRootObject(kISSUER, 4194304, 1, 10, 2, kTXN_ID, 3); + createAccountRootObject(kIssuer, 4194304, 1, 10, 2, kTxnId, 3); EXPECT_CALL( *backend_, doFetchLedgerObject(ripple::keylet::account(issuerAccount).key, testing::_, testing::_) ) .WillOnce(testing::Return(issuerAccountRoot.getSerializer().peekData())); - testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, PublishesMPTokenIssuanceCreateTx) { - constexpr auto kMPTOKEN_ISSUANCE_CREATE_TRAN_V1 = + constexpr auto kMptokenIssuanceCreateTranV1 = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -1330,23 +1330,23 @@ TEST_F(FeedTransactionTest, PublishesMPTokenIssuanceCreateTx) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); - auto const trans = createMPTIssuanceCreateTxWithMetadata(kACCOUNT1, 12, 1); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); + auto const trans = createMPTIssuanceCreateTxWithMetadata(kAccount1, 12, 1); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kMPTOKEN_ISSUANCE_CREATE_TRAN_V1))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kMptokenIssuanceCreateTranV1))); - testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubCount(), 0); - testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } TEST_F(FeedTransactionTest, PublishesMPTokenAuthorizeTx) { - constexpr auto kMPTOKEN_AUTHORIZE_TRAN_V1 = + constexpr auto kMptokenAuthorizeTranV1 = R"JSON({ "transaction": { "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -1390,18 +1390,18 @@ TEST_F(FeedTransactionTest, PublishesMPTokenAuthorizeTx) EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(sessionPtr); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); // The issuance ID that this transaction is authorizing - auto const mptIssuanceID = ripple::makeMptID(1, getAccountIdWithString(kACCOUNT1)); - auto const trans = createMPTokenAuthorizeTxWithMetadata(kACCOUNT1, mptIssuanceID, 15, 5); + auto const mptIssuanceID = ripple::makeMptID(1, getAccountIdWithString(kAccount1)); + auto const trans = createMPTokenAuthorizeTxWithMetadata(kAccount1, mptIssuanceID, 15, 5); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); - EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kMPTOKEN_AUTHORIZE_TRAN_V1))); + EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kMptokenAuthorizeTranV1))); - testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); testFeedPtr->unsub(sessionPtr); - testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); + testFeedPtr->pub(trans, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNetworkId); } struct TransactionFeedMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture { @@ -1429,12 +1429,12 @@ TEST_F(TransactionFeedMockPrometheusTest, subUnsub) testFeedPtr_->sub(sessionPtr_); testFeedPtr_->unsub(sessionPtr_); - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); EXPECT_CALL(*mockSessionPtr_, onDisconnect); testFeedPtr_->sub(account, sessionPtr_); testFeedPtr_->unsub(account, sessionPtr_); - auto const issue1 = getIssue(kCURRENCY, kISSUER); + auto const issue1 = getIssue(kCurrency, kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr_, onDisconnect); testFeedPtr_->sub(book, sessionPtr_); @@ -1464,10 +1464,10 @@ TEST_F(TransactionFeedMockPrometheusTest, AutoDisconnect) }); testFeedPtr_->sub(sessionPtr_); - auto const account = getAccountIdWithString(kACCOUNT1); + auto const account = getAccountIdWithString(kAccount1); testFeedPtr_->sub(account, sessionPtr_); - auto const issue1 = getIssue(kCURRENCY, kISSUER); + auto const issue1 = getIssue(kCurrency, kIssuer); ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; testFeedPtr_->sub(book, sessionPtr_); diff --git a/tests/unit/migration/cassandra/SpecTests.cpp b/tests/unit/migration/cassandra/SpecTests.cpp index da69e1a91..5d5e89a20 100644 --- a/tests/unit/migration/cassandra/SpecTests.cpp +++ b/tests/unit/migration/cassandra/SpecTests.cpp @@ -10,8 +10,8 @@ class Empty {}; struct SimpleTestTable { using Row = std::tuple; - static constexpr char const* kPARTITION_KEY = "key"; - static constexpr char const* kTABLE_NAME = "test"; + static constexpr char const* kPartitionKey = "key"; + static constexpr char const* kTableName = "test"; }; } // namespace TEST(MigrationSpec, TableSpec) diff --git a/tests/unit/rpc/APIVersionTests.cpp b/tests/unit/rpc/APIVersionTests.cpp index 83d65b667..2d3e5ea4c 100644 --- a/tests/unit/rpc/APIVersionTests.cpp +++ b/tests/unit/rpc/APIVersionTests.cpp @@ -8,9 +8,9 @@ namespace { -constexpr auto kDEFAULT_API_VERSION = 5u; -constexpr auto kMIN_API_VERSION = 2u; -constexpr auto kMAX_API_VERSION = 10u; +constexpr auto kDefaultApiVersion = 5u; +constexpr auto kMinApiVersion = 2u; +constexpr auto kMaxApiVersion = 10u; } // namespace @@ -20,14 +20,14 @@ namespace json = boost::json; class RPCAPIVersionTest : public virtual ::testing::Test { protected: - ProductionAPIVersionParser parser_{kDEFAULT_API_VERSION, kMIN_API_VERSION, kMAX_API_VERSION}; + ProductionAPIVersionParser parser_{kDefaultApiVersion, kMinApiVersion, kMaxApiVersion}; }; TEST_F(RPCAPIVersionTest, ReturnsDefaultVersionIfNotSpecified) { auto ver = parser_.parse(json::parse("{}").as_object()); EXPECT_TRUE(ver); - EXPECT_EQ(ver.value(), kDEFAULT_API_VERSION); + EXPECT_EQ(ver.value(), kDefaultApiVersion); } TEST_F(RPCAPIVersionTest, ReturnsErrorIfVersionHigherThanMaxSupported) @@ -80,9 +80,9 @@ TEST_F(RPCAPIVersionTest, ReturnsParsedVersionIfAllPreconditionsAreMet) TEST_F(RPCAPIVersionTest, GetsValuesFromConfigCorrectly) { ClioConfigDefinition const cfg{ - {"api_version.min", ConfigValue{ConfigType::Integer}.defaultValue(kMIN_API_VERSION)}, - {"api_version.max", ConfigValue{ConfigType::Integer}.defaultValue(kMAX_API_VERSION)}, - {"api_version.default", ConfigValue{ConfigType::Integer}.defaultValue(kDEFAULT_API_VERSION)} + {"api_version.min", ConfigValue{ConfigType::Integer}.defaultValue(kMinApiVersion)}, + {"api_version.max", ConfigValue{ConfigType::Integer}.defaultValue(kMaxApiVersion)}, + {"api_version.default", ConfigValue{ConfigType::Integer}.defaultValue(kDefaultApiVersion)} }; ProductionAPIVersionParser const configuredParser{cfg.getObject("api_version")}; @@ -106,7 +106,7 @@ TEST_F(RPCAPIVersionTest, GetsValuesFromConfigCorrectly) { auto ver = configuredParser.parse(json::parse(R"JSON({})JSON").as_object()); EXPECT_TRUE(ver); - EXPECT_EQ(ver.value(), kDEFAULT_API_VERSION); + EXPECT_EQ(ver.value(), kDefaultApiVersion); } { auto ver = diff --git a/tests/unit/rpc/ErrorTests.cpp b/tests/unit/rpc/ErrorTests.cpp index 1e1ee2d0d..553541501 100644 --- a/tests/unit/rpc/ErrorTests.cpp +++ b/tests/unit/rpc/ErrorTests.cpp @@ -170,7 +170,7 @@ INSTANTIATE_TEST_SUITE_P( "https://xrpl.org/docs/references/http-websocket-apis/ and update your request." } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(WarningCodeTest, WarningToJSON) @@ -264,5 +264,5 @@ INSTANTIATE_TEST_SUITE_P( "Code: 7003, Error: invalidResponse, Message: Rippled returned an invalid response." } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); diff --git a/tests/unit/rpc/ForwardingProxyTests.cpp b/tests/unit/rpc/ForwardingProxyTests.cpp index 7fa73e96a..c7fd322e0 100644 --- a/tests/unit/rpc/ForwardingProxyTests.cpp +++ b/tests/unit/rpc/ForwardingProxyTests.cpp @@ -29,7 +29,7 @@ using namespace util::config; namespace json = boost::json; namespace { -constexpr auto kCLIENT_IP = "127.0.0.1"; +constexpr auto kClientIp = "127.0.0.1"; } // namespace class RPCForwardingProxyTest : public HandlerBaseTest { @@ -255,7 +255,7 @@ INSTANTIATE_TEST_CASE_P( ShouldForwardTest, ShouldForwardParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(ShouldForwardParameterTest, Test) @@ -279,7 +279,7 @@ TEST_P(ShouldForwardParameterTest, Test) nullptr, tagFactory_, data::LedgerRange{}, - kCLIENT_IP, + kClientIp, testBundle.isAdmin, }; @@ -299,9 +299,7 @@ TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams) EXPECT_CALL( *rawBalancerPtr, - forwardToRippled( - forwarded.as_object(), std::make_optional(kCLIENT_IP), true, _ - ) + forwardToRippled(forwarded.as_object(), std::make_optional(kClientIp), true, _) ) .WillOnce(Return(json::object{})); @@ -318,7 +316,7 @@ TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams) nullptr, tagFactory_, data::LedgerRange{}, - kCLIENT_IP, + kClientIp, true, }; @@ -339,9 +337,7 @@ TEST_F(RPCForwardingProxyTest, ForwardingFailYieldsErrorStatus) EXPECT_CALL( *rawBalancerPtr, - forwardToRippled( - forwarded.as_object(), std::make_optional(kCLIENT_IP), true, _ - ) + forwardToRippled(forwarded.as_object(), std::make_optional(kClientIp), true, _) ) .WillOnce(Return(std::unexpected{rpc::ClioError::EtlInvalidResponse})); @@ -358,7 +354,7 @@ TEST_F(RPCForwardingProxyTest, ForwardingFailYieldsErrorStatus) nullptr, tagFactory_, data::LedgerRange{}, - kCLIENT_IP, + kClientIp, true, }; diff --git a/tests/unit/rpc/JsonBoolTests.cpp b/tests/unit/rpc/JsonBoolTests.cpp index 21b932fec..0c0198a92 100644 --- a/tests/unit/rpc/JsonBoolTests.cpp +++ b/tests/unit/rpc/JsonBoolTests.cpp @@ -71,7 +71,7 @@ INSTANTIATE_TEST_CASE_P( JsonBoolCheckGroup, JsonBoolTests, ValuesIn(JsonBoolTests::generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(JsonBoolTests, Parse) diff --git a/tests/unit/rpc/RPCEngineTests.cpp b/tests/unit/rpc/RPCEngineTests.cpp index 538226294..986f41fb5 100644 --- a/tests/unit/rpc/RPCEngineTests.cpp +++ b/tests/unit/rpc/RPCEngineTests.cpp @@ -44,7 +44,7 @@ using namespace testing; using namespace util::config; namespace { -constexpr auto kFORWARD_REPLY = R"JSON({ +constexpr auto kForwardReply = R"JSON({ "result": { "status": "success", "forwarded": true @@ -120,7 +120,7 @@ generateTestValuesForParametersTest() .isUnknownCmd = neverCalled, .handlerReturnError = false, .status = rpc::Status{}, - .response = boost::json::parse(kFORWARD_REPLY).as_object()}, + .response = boost::json::parse(kForwardReply).as_object()}, {.testName = "ForwardAdminCmd", .isAdmin = false, .method = "ledger", @@ -178,7 +178,7 @@ INSTANTIATE_TEST_CASE_P( RPCEngineFlow, RPCEngineFlowParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(RPCEngineFlowParameterTest, Test) @@ -199,7 +199,7 @@ TEST_P(RPCEngineFlowParameterTest, Test) EXPECT_CALL(*mockLoadBalancerPtr_, forwardToRippled) .WillOnce(Return( std::expected( - json::parse(kFORWARD_REPLY).as_object() + json::parse(kForwardReply).as_object() ) )); EXPECT_CALL(*handlerProvider, contains).WillOnce(Return(true)); @@ -394,7 +394,7 @@ INSTANTIATE_TEST_CASE_P( RPCEngineCache, RPCEngineCacheParameterTest, ValuesIn(generateCacheTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(RPCEngineCacheParameterTest, Test) diff --git a/tests/unit/rpc/RPCHelpersTests.cpp b/tests/unit/rpc/RPCHelpersTests.cpp index 3b2fa2010..011438243 100644 --- a/tests/unit/rpc/RPCHelpersTests.cpp +++ b/tests/unit/rpc/RPCHelpersTests.cpp @@ -53,17 +53,17 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kTXN_ID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kLEDGER_SEQ_OBJECT = 50; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kAMM_ACCOUNT = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kLPTOKEN_CURRENCY = "037C35306B24AAB7FF90848206E003279AA47090"; -constexpr auto kAMM_ID = 54321; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kIndex1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kTxnId = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kLedgerSeqObject = 50; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kAmmAccount = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kLptokenCurrency = "037C35306B24AAB7FF90848206E003279AA47090"; +constexpr auto kAmmId = 54321; } // namespace @@ -83,7 +83,7 @@ protected: TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidIndexNotHex) { util::spawn(ctx_, [this](boost::asio::yield_context yield) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto ret = traverseOwnedNodes(*backend_, account, 9, 10, "nothex,10", yield, [](auto) { }); @@ -97,7 +97,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidIndexNotHex) TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidPageNotInt) { util::spawn(ctx_, [this](boost::asio::yield_context yield) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto ret = traverseOwnedNodes(*backend_, account, 9, 10, "nothex,abc", yield, [](auto) { }); @@ -111,20 +111,20 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidPageNotInt) // limit = 10, return 2 objects TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarker) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); // return owner index ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); // return two payment channel objects std::vector bbs; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -145,7 +145,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarker) // limit = 10, return 10 objects and marker TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); @@ -153,16 +153,16 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) int objectsCount = 11; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); bbs.push_back(channel1.getSerializer().peekData()); objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ownerDir.setFieldU64(ripple::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -175,7 +175,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) auto ret = traverseOwnedNodes(*backend_, account, 9, 10, {}, yield, [&](auto) { count++; }); EXPECT_TRUE(ret.has_value()); EXPECT_EQ(count, 10); - EXPECT_EQ(ret.value().toString(), fmt::format("{},0", kINDEX1)); + EXPECT_EQ(ret.value().toString(), fmt::format("{},0", kIndex1)); }); ctx_.run(); } @@ -183,11 +183,11 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) // 10 objects per page, limit is 15, return the second page as marker TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto ownerDirKk = ripple::keylet::ownerDir(account).key; - static constexpr auto kNEXT_PAGE = 99; - static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + static constexpr auto kNextPage = 99; + static constexpr auto kLimit = 15; + auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -195,11 +195,11 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) int objectsCount = 10; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); objectsCount--; } objectsCount = 15; @@ -208,12 +208,12 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + ownerDir.setFieldU64(ripple::sfIndexNext, kNextPage); // first page 's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kIndex1); // second page's next page is 0 ownerDir2.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) @@ -225,10 +225,10 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) util::spawn(ctx_, [&, this](boost::asio::yield_context yield) { auto count = 0; auto ret = - traverseOwnedNodes(*backend_, account, 9, kLIMIT, {}, yield, [&](auto) { count++; }); + traverseOwnedNodes(*backend_, account, 9, kLimit, {}, yield, [&](auto) { count++; }); EXPECT_TRUE(ret.has_value()); - EXPECT_EQ(count, kLIMIT); - EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kINDEX1, kNEXT_PAGE)); + EXPECT_EQ(count, kLimit); + EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kIndex1, kNextPage)); }); ctx_.run(); } @@ -236,21 +236,21 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) // Send a valid marker TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), 99).key; - static constexpr auto kLIMIT = 8; - static constexpr auto kPAGE_NUM = 99; + static constexpr auto kLimit = 8; + static constexpr auto kPageNum = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; int objectsCount = 10; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); objectsCount--; } objectsCount = 10; @@ -259,7 +259,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ownerDir.setFieldU64(ripple::sfIndexNext, 0); // return ownerdir when search by marker ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) @@ -274,14 +274,14 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) *backend_, account, 9, - kLIMIT, - fmt::format("{},{}", kINDEX1, kPAGE_NUM), + kLimit, + fmt::format("{},{}", kIndex1, kPageNum), yield, [&](auto) { count++; } ); EXPECT_TRUE(ret.has_value()); - EXPECT_EQ(count, kLIMIT); - EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kINDEX1, kPAGE_NUM)); + EXPECT_EQ(count, kLimit); + EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kIndex1, kPageNum)); }); ctx_.run(); } @@ -290,22 +290,22 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) // return invalid params error TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), 99).key; - static constexpr auto kLIMIT = 8; - static constexpr auto kPAGE_NUM = 99; + static constexpr auto kLimit = 8; + static constexpr auto kPageNum = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); int objectsCount = 10; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ownerDir.setFieldU64(ripple::sfIndexNext, 0); // return ownerdir when search by marker ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) @@ -317,8 +317,8 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker) *backend_, account, 9, - kLIMIT, - fmt::format("{},{}", kINDEX2, kPAGE_NUM), + kLimit, + fmt::format("{},{}", kIndex2, kPageNum), yield, [&](auto) { count++; } ); @@ -422,13 +422,13 @@ TEST_F(RPCHelpersTest, DeliverMaxAliasV1) TEST_F(RPCHelpersTest, DeliverMaxAliasV2) { - constexpr auto kJSON = R"JSON({ + constexpr auto kJson = R"JSON({ "TransactionType": "Payment", "Amount": { "test": "test" } })JSON"; - auto req = boost::json::parse(kJSON).as_object(); + auto req = boost::json::parse(kJson).as_object(); insertDeliverMaxAlias(req, 2); EXPECT_EQ( @@ -446,14 +446,14 @@ TEST_F(RPCHelpersTest, DeliverMaxAliasV2) TEST_F(RPCHelpersTest, LedgerHeaderJson) { - auto const ledgerHeader = createLedgerHeader(kINDEX1, 30); + auto const ledgerHeader = createLedgerHeader(kIndex1, 30); auto const binJson = toJson(ledgerHeader, true, 1u); - constexpr auto kEXPECT_BIN = R"JSON({ + constexpr auto kExpectBin = R"JSON({ "ledger_data": "0000001E000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "closed": true })JSON"; - EXPECT_EQ(binJson, boost::json::parse(kEXPECT_BIN)); + EXPECT_EQ(binJson, boost::json::parse(kExpectBin)); auto const expectJson = fmt::format( R"JSON({{ @@ -470,7 +470,7 @@ TEST_F(RPCHelpersTest, LedgerHeaderJson) "transaction_hash": "0000000000000000000000000000000000000000000000000000000000000000", "closed": true }})JSON", - kINDEX1, + kIndex1, 30 ); auto json = toJson(ledgerHeader, false, 1u); @@ -481,7 +481,7 @@ TEST_F(RPCHelpersTest, LedgerHeaderJson) TEST_F(RPCHelpersTest, LedgerHeaderJsonV2) { - auto const ledgerHeader = createLedgerHeader(kINDEX1, 30); + auto const ledgerHeader = createLedgerHeader(kIndex1, 30); auto const expectJson = fmt::format( R"JSON({{ @@ -498,7 +498,7 @@ TEST_F(RPCHelpersTest, LedgerHeaderJsonV2) "transaction_hash": "0000000000000000000000000000000000000000000000000000000000000000", "closed": true }})JSON", - kINDEX1, + kIndex1, 30 ); auto json = toJson(ledgerHeader, false, 2u); @@ -509,7 +509,7 @@ TEST_F(RPCHelpersTest, LedgerHeaderJsonV2) TEST_F(RPCHelpersTest, TransactionAndMetadataBinaryJsonV1) { - auto const txMeta = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 30, 1, kINDEX1, kINDEX2); + auto const txMeta = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 30, 1, kIndex1, kIndex2); auto const json = toJsonWithBinaryTx(txMeta, 1); EXPECT_TRUE(json.contains(JS(tx_blob))); EXPECT_TRUE(json.contains(JS(meta))); @@ -517,7 +517,7 @@ TEST_F(RPCHelpersTest, TransactionAndMetadataBinaryJsonV1) TEST_F(RPCHelpersTest, TransactionAndMetadataBinaryJsonV2) { - auto const txMeta = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 30, 1, kINDEX1, kINDEX2); + auto const txMeta = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 30, 1, kIndex1, kIndex2); auto const json = toJsonWithBinaryTx(txMeta, 2); EXPECT_TRUE(json.contains(JS(tx_blob))); EXPECT_TRUE(json.contains(JS(meta_blob))); @@ -525,12 +525,12 @@ TEST_F(RPCHelpersTest, TransactionAndMetadataBinaryJsonV2) TEST_F(RPCHelpersTest, ParseIssue) { - constexpr auto kJSON = R"JSON({ + constexpr auto kJson = R"JSON({ "issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun", "currency": "JPY" })JSON"; - auto issue = parseIssue(boost::json::parse(kJSON).as_object()); - EXPECT_TRUE(issue.account == getAccountIdWithString(kACCOUNT2)); + auto issue = parseIssue(boost::json::parse(kJson).as_object()); + EXPECT_TRUE(issue.account == getAccountIdWithString(kAccount2)); issue = parseIssue(boost::json::parse(R"JSON({"currency": "XRP"})JSON").as_object()); EXPECT_TRUE(ripple::isXRP(issue.currency)); @@ -544,11 +544,11 @@ TEST_F(RPCHelpersTest, ParseIssue) std::runtime_error ); - constexpr auto kJSON2 = R"JSON({ + constexpr auto kJson2 = R"JSON({ "issuer": "abcd", "currency": "JPY" })JSON"; - EXPECT_THROW(parseIssue(boost::json::parse(kJSON2).as_object()), std::runtime_error); + EXPECT_THROW(parseIssue(boost::json::parse(kJson2).as_object()), std::runtime_error); EXPECT_THROW( parseIssue( @@ -561,245 +561,245 @@ TEST_F(RPCHelpersTest, ParseIssue) TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) { - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const issuerKey = ripple::keylet::account(account); // returns empty blob - ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(std::optional{})); runSpawn([&](boost::asio::yield_context yield) { // return false: blob doesn't exist EXPECT_FALSE(fetchAndCheckAnyFlagsExists( - *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLedgerSeqObject, issuerKey, {ripple::lsfHighDeepFreeze}, yield )); }); } TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag) { - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const issuerKey = ripple::keylet::account(account); // create account with highDeepFreeze Flag auto const accountObject = - createAccountRootObject(kACCOUNT, ripple::lsfHighDeepFreeze, 1, 10, 2, kTXN_ID, 3); + createAccountRootObject(kAccount, ripple::lsfHighDeepFreeze, 1, 10, 2, kTxnId, 3); - ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { // returns true: accountObject has the highDeepFreeze flag EXPECT_TRUE(fetchAndCheckAnyFlagsExists( - *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLedgerSeqObject, issuerKey, {ripple::lsfHighDeepFreeze}, yield )); }); } TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreezeFlag) { - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const issuerKey = ripple::keylet::account(account); // create account with lowDeepFreeze Flag auto const accountObject = - createAccountRootObject(kACCOUNT, ripple::lsfLowDeepFreeze, 1, 10, 2, kTXN_ID, 3); + createAccountRootObject(kAccount, ripple::lsfLowDeepFreeze, 1, 10, 2, kTxnId, 3); - ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { // returns false: accountObject has the lowDeepFreeze flag EXPECT_FALSE(fetchAndCheckAnyFlagsExists( - *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLedgerSeqObject, issuerKey, {ripple::lsfHighDeepFreeze}, yield )); }); } TEST_F(RPCHelpersTest, isGlobalFrozen_AccountIsGlobalFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const issuerKey = ripple::keylet::account(account); auto const accountObject = - createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + createAccountRootObject(kAccount, ripple::lsfGlobalFreeze, 1, 10, 2, kTxnId, 3); - ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { // returns false: accountObject has the lowDeepFreeze flag - EXPECT_TRUE(isGlobalFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, yield)); + EXPECT_TRUE(isGlobalFrozen(*backend_, kLedgerSeqObject, account, yield)); }); } TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsDeepFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount); + auto const account2 = getAccountIdWithString(kAccount2); // create a trustline between account and account2 and is deep frozen auto const trustLineKey = - ripple::keylet::line(account, account2, ripple::Currency{kCURRENCY}).key; + ripple::keylet::line(account, account2, ripple::Currency{kCurrency}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze + "USD", kAccount, 8, kAccount, 1000, kAccount2, 2000, kIndex1, 2, ripple::lsfLowDeepFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { EXPECT_TRUE(isDeepFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield + *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account2, yield )); }); } TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsNotDeepFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount); + auto const account2 = getAccountIdWithString(kAccount2); // create a trustline between account and account2 that is frozen (NOT DeepFrozen) auto const trustLineKey = - ripple::keylet::line(account, account2, ripple::Currency{kCURRENCY}).key; + ripple::keylet::line(account, account2, ripple::Currency{kCurrency}).key; auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kAccount, 8, kAccount, 1000, kAccount2, 2000, kIndex1, 2, ripple::lsfLowFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustlineFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { EXPECT_FALSE(isDeepFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield + *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account2, yield )); }); } TEST_F(RPCHelpersTest, isDeepFrozen_IssuerAndAccountIsSameWillNotBeDeepFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); auto const trustLineKey = - ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key; + ripple::keylet::line(account, issuer, ripple::Currency{kCurrency}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze + "USD", kAccount, 8, kAccount, 1000, kAccount2, 2000, kIndex1, 2, ripple::lsfLowDeepFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { // both accounts are same so trustline is not deep frozen EXPECT_FALSE(isDeepFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield + *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account, yield )); }); } TEST_F(RPCHelpersTest, isFrozen_IssuerAccountIsGlobalFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); auto const accountObject = - createAccountRootObject(kACCOUNT2, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + createAccountRootObject(kAccount2, ripple::lsfGlobalFreeze, 1, 10, 2, kTxnId, 3); auto const issuerKey = ripple::keylet::account(issuer).key; - ON_CALL(*backend_, doFetchLedgerObject(issuerKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(issuerKey, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { EXPECT_TRUE(isFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, issuer, yield + *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, issuer, yield )); }); } TEST_F(RPCHelpersTest, isFrozen_IssuerAndAccountIsSameWillNotBeFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); auto const trustLineKey = - ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key; + ripple::keylet::line(account, issuer, ripple::Currency{kCurrency}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze + "USD", kAccount, 8, kAccount, 1000, kAccount2, 2000, kIndex1, 2, ripple::lsfHighFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { EXPECT_FALSE(isFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield + *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account, yield )); }); } TEST_F(RPCHelpersTest, isFrozen_IssuerTrustLineIsFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); + ripple::Currency const currency{kCurrency}; auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; // issuer is higher than account, so the correct flag to set is High freeze auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze + "USD", kAccount, 8, kAccount, 1000, kAccount2, 2000, kIndex1, 2, ripple::lsfHighFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustlineFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_TRUE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, currency, issuer, yield)); + EXPECT_TRUE(isFrozen(*backend_, kLedgerSeqObject, account, currency, issuer, yield)); }); } TEST_F(RPCHelpersTest, isFrozen_IssuerWithLowFreezeIsNotFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); + ripple::Currency const currency{kCurrency}; auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; // issuer is higher than account, but the flag set here is low freeze auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kAccount, 8, kAccount, 1000, kAccount2, 2000, kIndex1, 2, ripple::lsfLowFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustlineFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_FALSE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, currency, issuer, yield)); + EXPECT_FALSE(isFrozen(*backend_, kLedgerSeqObject, account, currency, issuer, yield)); }); } TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); + ripple::Currency const currency{kCurrency}; auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; auto const trustLine = createRippleStateLedgerObject( - kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, 0 + kCurrency, kAccount2, 500, kAccount, 1000, kAccount2, 1000, kTxnId, 1, 0 ); - EXPECT_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillOnce(Return(trustLine.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { auto const result = accountHolds( *backend_, *mockAmendmentCenterPtr_, - kLEDGER_SEQ_OBJECT, + kLedgerSeqObject, account, currency, issuer, @@ -807,27 +807,27 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen) yield ); // Check issuer has a balance of 500 - EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 500)); + EXPECT_EQ(result, ripple::STAmount(getIssue(kCurrency, kAccount2), 500)); }); } TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); + ripple::Currency const currency{kCurrency}; auto const key = ripple::keylet::line(account, issuer, currency).key; // return no trustline found - EXPECT_CALL(*backend_, doFetchLedgerObject(key, kLEDGER_SEQ_OBJECT, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(key, kLedgerSeqObject, _)) .WillOnce(Return(std::nullopt)); runSpawn([&](boost::asio::yield_context yield) { auto const result = accountHolds( *backend_, *mockAmendmentCenterPtr_, - kLEDGER_SEQ_OBJECT, + kLedgerSeqObject, account, currency, issuer, @@ -835,70 +835,61 @@ TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine) yield ); // balance is 0 as trustline is frozen - EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0)); + EXPECT_EQ(result, ripple::STAmount(getIssue(kCurrency, kAccount2), 0)); }); } TEST_F(RPCHelpersTest, AccountHolds_TrustLineButFrozen) { - auto const account = getAccountIdWithString(kACCOUNT); - auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + auto const account = getAccountIdWithString(kAccount); + auto const issuer = getAccountIdWithString(kAccount2); + ripple::Currency const currency{kCurrency}; // balance of 500, but trustline is frozen auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; auto const trustLine = createRippleStateLedgerObject( - kCURRENCY, - kACCOUNT2, - 500, - kACCOUNT, - 1000, - kACCOUNT2, - 1000, - kTXN_ID, - 1, - ripple::lsfHighFreeze + kCurrency, kAccount2, 500, kAccount, 1000, kAccount2, 1000, kTxnId, 1, ripple::lsfHighFreeze ); - ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) + ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) .WillByDefault(Return(trustLine.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { auto const result = accountHolds( *backend_, *mockAmendmentCenterPtr_, - kLEDGER_SEQ_OBJECT, + kLedgerSeqObject, account, currency, issuer, true, yield ); - EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0)); + EXPECT_EQ(result, ripple::STAmount(getIssue(kCurrency, kAccount2), 0)); }); } TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) { - auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT); - auto account = getAccountIdWithString(kACCOUNT); + auto ammAccount = getAccountIdWithString(kAmmAccount); + auto account = getAccountIdWithString(kAccount); auto const lptRippleState = createRippleStateLedgerObject( - kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 + kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) .Times(2) .WillRepeatedly(Return(lptRippleState.getSerializer().peekData())); - auto const ammID = ripple::uint256{kAMM_ID}; + auto const ammID = ripple::uint256{kAmmId}; auto const ammAccountKk = ripple::keylet::account(ammAccount).key; auto const ammAccountRoot = - createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); + createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_)) .WillOnce(Return(ammAccountRoot.getSerializer().peekData())); @@ -915,7 +906,7 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + ripple::to_currency(kLptokenCurrency), ammAccount, true, yield @@ -927,11 +918,11 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) { - auto account = getAccountIdWithString(kACCOUNT); - auto account2 = getAccountIdWithString(kACCOUNT2); + auto account = getAccountIdWithString(kAccount); + auto account2 = getAccountIdWithString(kAccount2); auto const usdRippleState = createRippleStateLedgerObject( - "USD", kACCOUNT2, 100, kACCOUNT, 100, kACCOUNT2, 100, kTXN_ID, 3 + "USD", kAccount2, 100, kAccount, 100, kAccount2, 100, kTxnId, 3 ); auto const usdRippleStateKk = ripple::keylet::line(account2, account, ripple::to_currency("USD")).key; @@ -948,7 +939,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) .WillOnce(Return(true)); auto const account2Kk = ripple::keylet::account(account2).key; - auto const account2Root = createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2, 0); + auto const account2Root = createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(account2Kk, testing::_, testing::_)) .Times(2) @@ -972,15 +963,15 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) { - auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT); - auto account = getAccountIdWithString(kACCOUNT); - auto issuer = getAccountIdWithString(kISSUER); + auto ammAccount = getAccountIdWithString(kAmmAccount); + auto account = getAccountIdWithString(kAccount); + auto issuer = getAccountIdWithString(kIssuer); auto const lptRippleState = createRippleStateLedgerObject( - kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 + kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -993,19 +984,18 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) ) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; + auto const ammID = ripple::uint256{kAmmId}; auto const ammAccountKk = ripple::keylet::account(ammAccount).key; auto const ammAccountRoot = - createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); + createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); // accountroot fetched twice, once in isFrozen, once in accountHolds EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_)) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject( - kAMM_ACCOUNT, "USD", kISSUER, "XRP", ripple::toBase58(ripple::xrpAccount()) - ); + auto const amm = + createAmmObject(kAmmAccount, "USD", kIssuer, "XRP", ripple::toBase58(ripple::xrpAccount())); EXPECT_CALL( *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) ) @@ -1014,7 +1004,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) auto const issuerKk = ripple::keylet::account(issuer).key; auto const issuerAccountRoot = - createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0); + createAccountRootObject(kIssuer, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); @@ -1024,7 +1014,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + ripple::to_currency(kLptokenCurrency), ammAccount, true, yield @@ -1036,15 +1026,15 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) { - auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT); - auto account = getAccountIdWithString(kACCOUNT); - auto issuer = getAccountIdWithString(kISSUER); + auto ammAccount = getAccountIdWithString(kAmmAccount); + auto account = getAccountIdWithString(kAccount); + auto issuer = getAccountIdWithString(kIssuer); auto const lptRippleState = createRippleStateLedgerObject( - kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 + kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)).Times(2); @@ -1057,19 +1047,18 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) ) .WillOnce(testing::Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; + auto const ammID = ripple::uint256{kAmmId}; auto const ammAccountKk = ripple::keylet::account(ammAccount).key; auto const ammAccountRoot = - createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); + createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); // accountroot fetched twice, once in isFrozen, once in accountHolds EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_)) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER - ); + auto const amm = + createAmmObject(kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kIssuer); EXPECT_CALL( *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) ) @@ -1077,7 +1066,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) auto const issuerKk = ripple::keylet::account(issuer).key; auto const issuerAccountRoot = - createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0); + createAccountRootObject(kIssuer, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); @@ -1087,7 +1076,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + ripple::to_currency(kLptokenCurrency), ammAccount, true, yield @@ -1099,15 +1088,15 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) { - auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT); - auto account = getAccountIdWithString(kACCOUNT); - auto issuer = getAccountIdWithString(kISSUER); + auto ammAccount = getAccountIdWithString(kAmmAccount); + auto account = getAccountIdWithString(kAccount); + auto issuer = getAccountIdWithString(kIssuer); auto const lptRippleState = createRippleStateLedgerObject( - kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 + kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -1120,31 +1109,30 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) ) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; + auto const ammID = ripple::uint256{kAmmId}; auto const ammAccountKk = ripple::keylet::account(ammAccount).key; auto const ammAccountRoot = - createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); + createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); // accountroot fetched twice, once in isFrozen, once in accountHolds EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_)) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER - ); + auto const amm = + createAmmObject(kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kIssuer); EXPECT_CALL( *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) ) .WillOnce(Return(amm.getSerializer().peekData())); auto const issuerKk = ripple::keylet::account(issuer).key; - auto const issuerAccountRoot = createAccountRootObject(kISSUER, 0, 2, 200, 2, kINDEX1, 2, 0); + auto const issuerAccountRoot = createAccountRootObject(kIssuer, 0, 2, 200, 2, kIndex1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); auto const usdRippleState = - createRippleStateLedgerObject("USD", kISSUER, 100, kACCOUNT, 100, kISSUER, 100, kTXN_ID, 3); + createRippleStateLedgerObject("USD", kIssuer, 100, kAccount, 100, kIssuer, 100, kTxnId, 3); auto const usdRippleStateKk = ripple::keylet::line(issuer, account, ripple::to_currency("USD")).key; @@ -1157,7 +1145,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + ripple::to_currency(kLptokenCurrency), ammAccount, true, yield @@ -1380,7 +1368,7 @@ INSTANTIATE_TEST_CASE_P( IsAdminCmdTest, IsAdminCmdParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(IsAdminCmdParameterTest, Test) @@ -1465,5 +1453,5 @@ INSTANTIATE_TEST_SUITE_P( true } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); diff --git a/tests/unit/rpc/WorkQueueTests.cpp b/tests/unit/rpc/WorkQueueTests.cpp index 64fde5703..872280534 100644 --- a/tests/unit/rpc/WorkQueueTests.cpp +++ b/tests/unit/rpc/WorkQueueTests.cpp @@ -47,10 +47,10 @@ struct WorkQueueTest : WithPrometheus, RPCWorkQueueTestBase { TEST_F(WorkQueueTest, WhitelistedExecutionCountAddsUp) { - static constexpr auto kTOTAL = 512u; + static constexpr auto kTotal = 512u; std::atomic_uint32_t executeCount = 0u; - for (auto i = 0u; i < kTOTAL; ++i) { + for (auto i = 0u; i < kTotal; ++i) { queue.postCoro( [&executeCount](auto /* yield */) { ++executeCount; }, /* isWhiteListed = */ true ); @@ -60,21 +60,21 @@ TEST_F(WorkQueueTest, WhitelistedExecutionCountAddsUp) auto const report = queue.report(); - EXPECT_EQ(executeCount, kTOTAL); - EXPECT_EQ(report.at("queued"), kTOTAL); + EXPECT_EQ(executeCount, kTotal); + EXPECT_EQ(report.at("queued"), kTotal); EXPECT_EQ(report.at("current_queue_size"), 0); EXPECT_EQ(report.at("max_queue_size"), 2); } TEST_F(WorkQueueTest, NonWhitelistedPreventSchedulingAtQueueLimitExceeded) { - static constexpr auto kTOTAL = 3u; + static constexpr auto kTotal = 3u; auto unblocked = false; std::mutex mtx; std::condition_variable cv; - for (auto i = 0u; i < kTOTAL; ++i) { + for (auto i = 0u; i < kTotal; ++i) { auto res = queue.postCoro( [&](auto /* yield */) { std::unique_lock lk{mtx}; @@ -83,7 +83,7 @@ TEST_F(WorkQueueTest, NonWhitelistedPreventSchedulingAtQueueLimitExceeded) /* isWhiteListed = */ false ); - if (i == kTOTAL - 1) { + if (i == kTotal - 1) { EXPECT_FALSE(res); std::unique_lock const lk{mtx}; @@ -100,7 +100,7 @@ TEST_F(WorkQueueTest, NonWhitelistedPreventSchedulingAtQueueLimitExceeded) struct WorkQueueDelayedStartTest : WithPrometheus { WorkQueue queue{ - WorkQueue::kDONT_START_PROCESSING_TAG, + WorkQueue::kDontStartProcessingTag, /* numWorkers = */ 1, /* maxSize = */ 100 }; @@ -129,7 +129,7 @@ TEST_F(WorkQueueDelayedStartTest, WaitTimeIncludesDelayBeforeStartProcessing) struct WorkQueuePriorityTest : WithPrometheus { WorkQueue queue{ - WorkQueue::kDONT_START_PROCESSING_TAG, + WorkQueue::kDontStartProcessingTag, /* numWorkers = */ 1, /* maxSize = */ 100 }; @@ -137,11 +137,11 @@ struct WorkQueuePriorityTest : WithPrometheus { TEST_F(WorkQueuePriorityTest, HighPriorityTasks) { - static constexpr auto kTOTAL = 10; + static constexpr auto kTotal = 10; std::vector executionOrder; std::mutex mtx; - for (int i = 0; i < kTOTAL; ++i) { + for (int i = 0; i < kTotal; ++i) { queue.postCoro( [&](auto) { std::scoped_lock const lock(mtx); @@ -278,7 +278,7 @@ TEST_F(WorkQueueDeathTest, DISABLED_ExecuteTaskAssertsWhenQueueIsEmpty) EXPECT_DEATH( { WorkQueue queue( - WorkQueue::kDONT_START_PROCESSING_TAG, /* numWorkers = */ 1, /* maxSize = */ 2 + WorkQueue::kDontStartProcessingTag, /* numWorkers = */ 1, /* maxSize = */ 2 ); queue.startProcessing(); // the actual queue is empty which will lead to assertion // failure diff --git a/tests/unit/rpc/common/impl/HandlerProviderTests.cpp b/tests/unit/rpc/common/impl/HandlerProviderTests.cpp index ae2d6de3d..22bd4cb00 100644 --- a/tests/unit/rpc/common/impl/HandlerProviderTests.cpp +++ b/tests/unit/rpc/common/impl/HandlerProviderTests.cpp @@ -24,15 +24,15 @@ struct ProductionHandlerProviderTest : util::prometheus::WithPrometheus, MockBac util::config::ClioConfigDefinition config{ {"api_version.default", util::config::ConfigValue{util::config::ConfigType::Integer}.defaultValue( - rpc::kAPI_VERSION_DEFAULT + rpc::kApiVersionDefault )}, {"api_version.min", util::config::ConfigValue{util::config::ConfigType::Integer}.defaultValue( - rpc::kAPI_VERSION_MIN + rpc::kApiVersionMin )}, {"api_version.max", util::config::ConfigValue{util::config::ConfigType::Integer}.defaultValue( - rpc::kAPI_VERSION_MAX + rpc::kApiVersionMax )}, }; StrictMockSubscriptionManagerSharedPtr subscriptionManagerMock; diff --git a/tests/unit/rpc/handlers/AMMInfoTests.cpp b/tests/unit/rpc/handlers/AMMInfoTests.cpp index b8c9348d4..51a02282d 100644 --- a/tests/unit/rpc/handlers/AMMInfoTests.cpp +++ b/tests/unit/rpc/handlers/AMMInfoTests.cpp @@ -32,16 +32,16 @@ using namespace testing; namespace { -constexpr auto kSEQ = 30; -constexpr auto kWRONG_AMM_ACCOUNT = "000S7XL6nxRAi7JcbJcn1Na179oF300000"; -constexpr auto kAMM_ACCOUNT = "rLcS7XL6nxRAi7JcbJcn1Na179oF3vdfbh"; -constexpr auto kAMM_ACCOUNT2 = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs"; -constexpr auto kLP_ISSUE_CURRENCY = "03930D02208264E2E40EC1B0C09E4DB96EE197B1"; -constexpr auto kNOTFOUND_ACCOUNT = "rBdLS7RVLqkPwnWQCT2bC6HJd6xGoBizq8"; -constexpr auto kAMM_ID = 54321; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kSeq = 30; +constexpr auto kWrongAmmAccount = "000S7XL6nxRAi7JcbJcn1Na179oF300000"; +constexpr auto kAmmAccount = "rLcS7XL6nxRAi7JcbJcn1Na179oF3vdfbh"; +constexpr auto kAmmAccounT2 = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs"; +constexpr auto kLpIssueCurrency = "03930D02208264E2E40EC1B0C09E4DB96EE197B1"; +constexpr auto kNotfoundAccount = "rBdLS7RVLqkPwnWQCT2bC6HJd6xGoBizq8"; +constexpr auto kAmmId = 54321; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; } // namespace @@ -130,7 +130,7 @@ INSTANTIATE_TEST_CASE_P( RPCAMMInfoGroup1, AMMInfoParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AMMInfoParameterTest, InvalidParams) @@ -150,10 +150,10 @@ TEST_P(AMMInfoParameterTest, InvalidParams) TEST_F(RPCAMMInfoHandlerTest, AccountNotFound) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); - auto const missingAccountKey = getAccountKey(kNOTFOUND_ACCOUNT); - auto const accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const accountKey = getAccountKey(kAMM_ACCOUNT); + auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); + auto const missingAccountKey = getAccountKey(kNotfoundAccount); + auto const accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); + auto const accountKey = getAccountKey(kAmmAccount); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(missingAccountKey, testing::_, testing::_)) @@ -161,20 +161,20 @@ TEST_F(RPCAMMInfoHandlerTest, AccountNotFound) ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}", "account": "{}" }})JSON", - kAMM_ACCOUNT, - kNOTFOUND_ACCOUNT + kAmmAccount, + kNotfoundAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -185,22 +185,22 @@ TEST_F(RPCAMMInfoHandlerTest, AccountNotFound) TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotExist) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kWRONG_AMM_ACCOUNT + kWrongAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "actMalformed"); @@ -210,22 +210,22 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotExist) TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotInDBIsMalformed) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -236,25 +236,25 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotInDBIsMalformed) TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotFoundMissingAmmField) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); - auto const accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); + auto const accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(accountRoot.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -265,16 +265,16 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotFoundMissingAmmField) TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); - auto const accountKey = getAccountKey(kAMM_ACCOUNT); - auto const ammId = ripple::uint256{kAMM_ID}; + auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); + auto const accountKey = getAccountKey(kAmmAccount); + auto const ammId = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammId); - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2 + kAmmAccounT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAmmAccounT2 ); - accountRoot.setFieldH256(ripple::sfAMMID, ripple::uint256{kAMM_ID}); + accountRoot.setFieldH256(ripple::sfAMMID, ripple::uint256{kAmmId}); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -282,18 +282,18 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -304,15 +304,15 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); - auto const accountKey = getAccountKey(kAMM_ACCOUNT); - auto const account2Key = getAccountKey(kAMM_ACCOUNT2); - auto const ammId = ripple::uint256{kAMM_ID}; + auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); + auto const accountKey = getAccountKey(kAmmAccount); + auto const account2Key = getAccountKey(kAmmAccounT2); + auto const ammId = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammId); - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto const ammObj = createAmmObject( - kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2 + kAmmAccounT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAmmAccounT2 ); accountRoot.setFieldH256(ripple::sfAMMID, ammId); @@ -324,18 +324,18 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) ON_CALL(*backend_, doFetchLedgerObject(account2Key, testing::_, testing::_)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -346,23 +346,23 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, + kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", - kAMM_ACCOUNT2, - kLP_ISSUE_CURRENCY + kAmmAccounT2, + kLpIssueCurrency ); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -374,22 +374,22 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto expectedResult = json::parse( fmt::format( R"JSON({{ @@ -413,12 +413,12 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLedgerHash ) ); @@ -429,31 +429,31 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account2, account1, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); - auto const account2Root = createAccountRootObject(kAMM_ACCOUNT2, 0, 2, 300, 2, kINDEX1, 2); + auto const account2Root = createAccountRootObject(kAmmAccounT2, 0, 2, 300, 2, kIndex1, 2); auto const ammObj = createAmmObject( - kAMM_ACCOUNT2, + kAmmAccounT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", - kAMM_ACCOUNT, - kLP_ISSUE_CURRENCY + kAmmAccount, + kLpIssueCurrency ); auto const lptCurrency = createLptCurrency("XRP", "JPY"); auto const accountHoldsKeylet = ripple::keylet::line(account2, account2, lptCurrency); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustline = createRippleStateLedgerObject( - kLP_ISSUE_CURRENCY, kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2 + kLpIssueCurrency, kAmmAccount, 12, kAmmAccounT2, 1000, kAmmAccount, 2000, kIndex1, 2 ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -463,26 +463,26 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(std::optional{})); - ON_CALL(*backend_, doFetchLedgerObject(accountHoldsKeylet.key, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(accountHoldsKeylet.key, kSeq, _)) .WillByDefault(Return(trustline.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}", "account": "{}" }})JSON", - kAMM_ACCOUNT, - kAMM_ACCOUNT2 + kAmmAccount, + kAmmAccounT2 ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto const expectedResult = json::parse( fmt::format( R"JSON({{ @@ -506,12 +506,12 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT2, + kLpIssueCurrency, + kAmmAccounT2, "JPY", - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kLEDGER_HASH + kAmmAccount, + kAmmAccounT2, + kLedgerHash ) ); @@ -522,23 +522,23 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, + kAmmAccounT2, "XRP", ripple::toBase58(ripple::xrpAccount()), - kLP_ISSUE_CURRENCY + kLpIssueCurrency ); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -550,22 +550,22 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto const expectedResult = json::parse( fmt::format( R"JSON({{ @@ -589,12 +589,12 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLedgerHash ) ); @@ -605,19 +605,18 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto ammObj = createAmmObject( - kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY - ); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); + auto ammObj = + createAmmObject(kAmmAccount, "USD", kAmmAccount, "JPY", kAmmAccounT2, kLpIssueCurrency); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -628,22 +627,22 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto const expectedResult = json::parse( fmt::format( R"JSON({{ @@ -672,14 +671,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "USD", - kAMM_ACCOUNT, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLedgerHash ) ); @@ -690,10 +689,10 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue1LineKey = @@ -701,35 +700,34 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto ammObj = createAmmObject( - kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY - ); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); + auto ammObj = + createAmmObject(kAmmAccount, "USD", kAmmAccount, "JPY", kAmmAccounT2, kLpIssueCurrency); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); // note: frozen flag will not be used for trustline1 because issuer == account auto const trustline1BalanceFrozen = createRippleStateLedgerObject( "USD", - kAMM_ACCOUNT, + kAmmAccount, 8, - kAMM_ACCOUNT, + kAmmAccount, 1000, - kAMM_ACCOUNT2, + kAmmAccounT2, 2000, - kINDEX1, + kIndex1, 2, ripple::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( "JPY", - kAMM_ACCOUNT, + kAmmAccount, 12, - kAMM_ACCOUNT2, + kAmmAccounT2, 1000, - kAMM_ACCOUNT, + kAmmAccount, 2000, - kINDEX1, + kIndex1, 2, ripple::lsfGlobalFreeze ); @@ -741,24 +739,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue1LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue1LineKey, kSeq, _)) .WillByDefault(Return(trustline1BalanceFrozen.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(trustline2BalanceFrozen.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto const expectedResult = json::parse( fmt::format( R"JSON({{ @@ -787,14 +785,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "USD", - kAMM_ACCOUNT, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLedgerHash ) ); @@ -805,10 +803,10 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue1LineKey = @@ -818,35 +816,34 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) // asset1 will be frozen because flag set here auto accountRoot = - createAccountRootObject(kAMM_ACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2); - auto ammObj = createAmmObject( - kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY - ); + createAccountRootObject(kAmmAccount, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2); + auto ammObj = + createAmmObject(kAmmAccount, "USD", kAmmAccount, "JPY", kAmmAccounT2, kLpIssueCurrency); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); // note: frozen flag will not be used for trustline1 because issuer == account auto const trustline1BalanceFrozen = createRippleStateLedgerObject( "USD", - kAMM_ACCOUNT, + kAmmAccount, 8, - kAMM_ACCOUNT, + kAmmAccount, 1000, - kAMM_ACCOUNT2, + kAmmAccounT2, 2000, - kINDEX1, + kIndex1, 2, ripple::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( "JPY", - kAMM_ACCOUNT, + kAmmAccount, 12, - kAMM_ACCOUNT2, + kAmmAccounT2, 1000, - kAMM_ACCOUNT, + kAmmAccount, 2000, - kINDEX1, + kIndex1, 2, ripple::lsfGlobalFreeze ); @@ -858,24 +855,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue1LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue1LineKey, kSeq, _)) .WillByDefault(Return(trustline1BalanceFrozen.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(trustline2BalanceFrozen.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto const expectedResult = json::parse( fmt::format( R"JSON({{ @@ -904,14 +901,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "USD", - kAMM_ACCOUNT, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLedgerHash ) ); @@ -922,28 +919,28 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, + kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", - kAMM_ACCOUNT2, - kLP_ISSUE_CURRENCY + kAmmAccounT2, + kLpIssueCurrency ); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject( - "JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0 + "JPY", kAmmAccounT2, -8, kAmmAccount, 1000, kAmmAccounT2, 2000, kIndex2, 2, 0 ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -953,22 +950,22 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(trustlineBalance.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto expectedResult = json::parse( fmt::format( R"JSON({{ @@ -992,12 +989,12 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLedgerHash ) ); @@ -1008,30 +1005,30 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, + kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", - kAMM_ACCOUNT2, - kLP_ISSUE_CURRENCY + kAmmAccounT2, + kLpIssueCurrency ); ammAddVoteSlot(ammObj, account1, 2, 4); ammAddVoteSlot(ammObj, account2, 4, 2); accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject( - "JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0 + "JPY", kAmmAccounT2, -8, kAmmAccount, 1000, kAmmAccounT2, 2000, kIndex2, 2, 0 ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -1041,22 +1038,22 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(trustlineBalance.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto expectedResult = json::parse( fmt::format( R"JSON({{ @@ -1092,14 +1089,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kAmmAccount, + kAmmAccounT2, + kLedgerHash ) ); @@ -1110,23 +1107,23 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) { - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const ammKey = ripple::uint256{kAmmId}; auto const ammKeylet = ripple::keylet::amm(ammKey); auto const feesKey = ripple::keylet::fees().key; auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, + kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", - kAMM_ACCOUNT2, - kLP_ISSUE_CURRENCY + kAmmAccounT2, + kLpIssueCurrency ); ammSetAuctionSlot( ammObj, @@ -1140,7 +1137,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) accountRoot.setFieldH256(ripple::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject( - "JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0 + "JPY", kAmmAccounT2, -8, kAmmAccount, 1000, kAmmAccounT2, 2000, kIndex2, 2, 0 ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -1150,22 +1147,22 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); - ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSeq, _)).WillByDefault(Return(feesObj)); + ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSeq, _)) .WillByDefault(Return(trustlineBalance.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "amm_account": "{}" }})JSON", - kAMM_ACCOUNT + kAmmAccount ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto expectedResult = json::parse( fmt::format( R"JSON({{ @@ -1204,15 +1201,15 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kAmmAccounT2, + kAmmAccount, + kAmmAccounT2, + kLedgerHash ) ); @@ -1223,18 +1220,17 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const issue1 = ripple::Issue(ripple::to_currency("JPY"), account1); auto const issue2 = ripple::Issue(ripple::to_currency("USD"), account2); auto const ammKeylet = ripple::keylet::amm(issue1, issue2); - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto ammObj = createAmmObject( - kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT, "USD", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY - ); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLP_ISSUE_CURRENCY}, account1}; + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); + auto ammObj = + createAmmObject(kAmmAccount, "JPY", kAmmAccount, "USD", kAmmAccounT2, kLpIssueCurrency); + auto const auctionIssue = ripple::Issue{ripple::Currency{kLpIssueCurrency}, account1}; ammSetAuctionSlot( ammObj, account2, @@ -1253,7 +1249,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "asset": {{ @@ -1265,14 +1261,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) "issuer": "{}" }} }})JSON", - kAMM_ACCOUNT, - kAMM_ACCOUNT2 + kAmmAccount, + kAmmAccounT2 ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto expectedResult = json::parse( fmt::format( R"JSON({{ @@ -1320,19 +1316,19 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "JPY", - kAMM_ACCOUNT, + kAmmAccount, "USD", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLpIssueCurrency, + kAmmAccount, + kAmmAccounT2, + kAmmAccount, + kAmmAccounT2, + kLedgerHash ) ); @@ -1343,19 +1339,18 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) { - auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); - auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); + auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); + auto const account1 = getAccountIdWithString(kAmmAccount); + auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const issue1 = ripple::Issue(ripple::to_currency("USD"), account1); auto const issue2 = ripple::Issue(ripple::to_currency("JPY"), account2); auto const ammKeylet = ripple::keylet::amm(issue1, issue2); // Note: order in the AMM object is different from the input - auto ammObj = createAmmObject( - kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT, "USD", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY - ); - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLP_ISSUE_CURRENCY}, account1}; + auto ammObj = + createAmmObject(kAmmAccount, "JPY", kAmmAccount, "USD", kAmmAccounT2, kLpIssueCurrency); + auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); + auto const auctionIssue = ripple::Issue{ripple::Currency{kLpIssueCurrency}, account1}; ammSetAuctionSlot( ammObj, account2, @@ -1374,7 +1369,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "asset": {{ @@ -1386,14 +1381,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) "issuer": "{}" }} }})JSON", - kAMM_ACCOUNT, - kAMM_ACCOUNT2 + kAmmAccount, + kAmmAccounT2 ) ); auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); auto expectedResult = json::parse( fmt::format( R"JSON({{ @@ -1441,19 +1436,19 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) "ledger_hash": "{}", "validated": true }})JSON", - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, + kLpIssueCurrency, + kAmmAccount, "USD", - kAMM_ACCOUNT, + kAmmAccount, "JPY", - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kLP_ISSUE_CURRENCY, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kAMM_ACCOUNT, - kAMM_ACCOUNT2, - kLEDGER_HASH + kAmmAccounT2, + kAmmAccount, + kLpIssueCurrency, + kAmmAccount, + kAmmAccounT2, + kAmmAccount, + kAmmAccounT2, + kLedgerHash ) ); diff --git a/tests/unit/rpc/handlers/AccountChannelsTests.cpp b/tests/unit/rpc/handlers/AccountChannelsTests.cpp index 9a517199d..7faddd04a 100644 --- a/tests/unit/rpc/handlers/AccountChannelsTests.cpp +++ b/tests/unit/rpc/handlers/AccountChannelsTests.cpp @@ -28,13 +28,13 @@ using namespace testing; namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kACCOUNT3 = "rB9BMzh27F3Q6a5FtGPDayQoCCEdiRdqcK"; -constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kTXN_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount3 = "rB9BMzh27F3Q6a5FtGPDayQoCCEdiRdqcK"; +constexpr auto kIndex1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; } // namespace @@ -55,7 +55,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitNotInt) "account": "{}", "limit": "t" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -76,7 +76,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitNegative) "account": "{}", "limit": -1 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -97,7 +97,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitZero) "account": "{}", "limit": 0 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -119,7 +119,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonHexLedgerHash) "limit": 10, "ledger_hash": "xxx" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -142,7 +142,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonStringLedgerHash) "limit": 10, "ledger_hash": 123 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -165,7 +165,7 @@ TEST_F(RPCAccountChannelsHandlerTest, InvalidLedgerIndexString) "limit": 10, "ledger_index": "notvalidated" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -187,7 +187,7 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerNotString) "account": "{}", "marker": 9 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -212,7 +212,7 @@ TEST_F(RPCAccountChannelsHandlerTest, InvalidMarker) "account": "{}", "marker": "123invalid" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -230,7 +230,7 @@ TEST_F(RPCAccountChannelsHandlerTest, InvalidMarker) "account": "{}", "marker": 401 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -278,7 +278,7 @@ TEST_F(RPCAccountChannelsHandlerTest, AccountNotString) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -288,8 +288,8 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -316,7 +316,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerStringIndex) "account": "{}", "ledger_index": "4" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -341,7 +341,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIntIndex) "account": "{}", "ledger_index": 4 }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -359,8 +359,8 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -369,8 +369,8 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash2) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -395,7 +395,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIndex2) "account": "{}", "ledger_index": "31" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -411,8 +411,8 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIndex2) // error case account not exist TEST_F(RPCAccountChannelsHandlerTest, NonExistAccount) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty @@ -424,8 +424,8 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistAccount) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -441,7 +441,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistAccount) // normal case when only provide account TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) { - static constexpr auto kCORRECT_OUTPUT = R"JSON({ + static constexpr auto kCorrectOutput = R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -471,11 +471,11 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) ] })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -485,7 +485,7 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) // return owner index containing 2 indexes ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -494,7 +494,7 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) // return two payment channel objects std::vector bbs; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -505,25 +505,25 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{AccountChannelsHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCorrectOutput), *output.result); }); } // normal case : limit is used TEST_F(RPCAccountChannelsHandlerTest, UseLimit) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -537,12 +537,12 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) auto repetitions = 50; while ((repetitions--) != 0) { - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); ripple::STObject const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel.getSerializer().peekData()); } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); // it should not appear in return marker,marker is the current page ownerDir.setFieldU64(ripple::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) @@ -560,7 +560,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) "account": "{}", "limit": 20 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -581,7 +581,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) "account": "{}", "limit": 9 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -596,7 +596,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) "account": "{}", "limit": 401 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -607,11 +607,11 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) // normal case : destination is used TEST_F(RPCAccountChannelsHandlerTest, UseDestination) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -626,22 +626,22 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) // 10 pay channel to Account2 auto repetitions = 10; while ((repetitions--) != 0) { - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); ripple::STObject const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel.getSerializer().peekData()); } // 20 pay channel to Account3 repetitions = 20; while ((repetitions--) != 0) { - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); ripple::STObject const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT3, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount3, 100, 10, 32, kTxnId, 28); bbs.push_back(channel.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -656,8 +656,8 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) "limit": 30, "destination_account": "{}" }})JSON", - kACCOUNT, - kACCOUNT3 + kAccount, + kAccount3 ) ); runSpawn([&, this](auto yield) { @@ -671,11 +671,11 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) // normal case : but the lines is empty TEST_F(RPCAccountChannelsHandlerTest, EmptyChannel) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -684,7 +684,7 @@ TEST_F(RPCAccountChannelsHandlerTest, EmptyChannel) .WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kINDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -694,7 +694,7 @@ TEST_F(RPCAccountChannelsHandlerTest, EmptyChannel) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -708,7 +708,7 @@ TEST_F(RPCAccountChannelsHandlerTest, EmptyChannel) // Return expiration cancel_offer source_tag destination_tag when available TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) { - static constexpr auto kCORRECT_OUTPUT = R"JSON({ + static constexpr auto kCorrectOutput = R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -746,11 +746,11 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) ] })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -760,7 +760,7 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) // return owner index ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -769,7 +769,7 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) // return two payment channel objects std::vector bbs; ripple::STObject channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); channel1.setFieldU32(ripple::sfExpiration, 100); channel1.setFieldU32(ripple::sfCancelAfter, 200); channel1.setFieldU32(ripple::sfSourceTag, 300); @@ -783,27 +783,27 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{AccountChannelsHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCorrectOutput), *output.result); }); } // normal case : test marker output correct TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto ownerDirKk = ripple::keylet::ownerDir(account).key; - static constexpr auto kNEXT_PAGE = 99; - static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + static constexpr auto kNextPage = 99; + static constexpr auto kLimit = 15; + auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something @@ -814,13 +814,13 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) std::vector bbs; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); // owner dir contains 10 indexes int objectsCount = 10; std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); objectsCount--; } // return 15 objects @@ -830,12 +830,12 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + ownerDir.setFieldU64(ripple::sfIndexNext, kNextPage); // first page 's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kIndex1); // second page's next page is 0 ownerDir2.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) @@ -850,8 +850,8 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); runSpawn([&, this](auto yield) { @@ -860,7 +860,7 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) ASSERT_TRUE(output); EXPECT_EQ( boost::json::value_to(output.result->as_object().at("marker")), - fmt::format("{},{}", kINDEX1, kNEXT_PAGE) + fmt::format("{},{}", kIndex1, kNextPage) ); EXPECT_EQ(output.result->as_object().at("channels").as_array().size(), 15); }); @@ -869,12 +869,12 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) // normal case : handler marker correctly TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; - static constexpr auto kNEXT_PAGE = 99; - static constexpr auto kLIMIT = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + static constexpr auto kNextPage = 99; + static constexpr auto kLimit = 15; + auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something @@ -885,17 +885,17 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) std::vector bbs; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - int objectsCount = kLIMIT; + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); + int objectsCount = kLimit; std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); bbs.push_back(channel1.getSerializer().peekData()); objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ownerDir.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -910,10 +910,10 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) "limit": {}, "marker": "{},{}" }})JSON", - kACCOUNT, - kLIMIT, - kINDEX1, - kNEXT_PAGE + kAccount, + kLimit, + kIndex1, + kNextPage ) ); runSpawn([&, this](auto yield) { @@ -923,17 +923,17 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) EXPECT_TRUE(output.result->as_object().if_contains("marker") == nullptr); // the first item is the marker itself, so the result will have limit-1 // items - EXPECT_EQ(output.result->as_object().at("channels").as_array().size(), kLIMIT - 1); + EXPECT_EQ(output.result->as_object().at("channels").as_array().size(), kLimit - 1); }); } TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -943,7 +943,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) // return owner index containing 2 indexes ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -952,7 +952,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) // return two payment channel objects std::vector bbs; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -964,8 +964,8 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountChannelsHandler::kLIMIT_MIN - 1 + kAccount, + AccountChannelsHandler::kLimitMin - 1 ) ); runSpawn([&, this](auto yield) { @@ -974,18 +974,18 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("channels").as_array().size(), 2); EXPECT_EQ( - output.result->as_object().at("limit").as_uint64(), AccountChannelsHandler::kLIMIT_MIN + output.result->as_object().at("limit").as_uint64(), AccountChannelsHandler::kLimitMin ); }); } TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -995,7 +995,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) // return owner index containing 2 indexes ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -1004,7 +1004,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) // return two payment channel objects std::vector bbs; ripple::STObject const channel1 = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -1016,8 +1016,8 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountChannelsHandler::kLIMIT_MAX + 1 + kAccount, + AccountChannelsHandler::kLimitMax + 1 ) ); runSpawn([&, this](auto yield) { @@ -1026,7 +1026,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("channels").as_array().size(), 2); EXPECT_EQ( - output.result->as_object().at("limit").as_uint64(), AccountChannelsHandler::kLIMIT_MAX + output.result->as_object().at("limit").as_uint64(), AccountChannelsHandler::kLimitMax ); }); } diff --git a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp index 614d739ce..d144c15e0 100644 --- a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp +++ b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp @@ -28,13 +28,13 @@ namespace json = boost::json; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kTXN_ID = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kTxnId = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; } // namespace @@ -47,24 +47,24 @@ struct RPCAccountCurrenciesHandlerTest : HandlerBaseTest { TEST_F(RPCAccountCurrenciesHandlerTest, AccountNotExist) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "actNotFound"); @@ -79,17 +79,17 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaIntSequence) ON_CALL(*backend_, fetchLedgerBySequence(30, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -99,26 +99,26 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaIntSequence) TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaStringSequence) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(12, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "{}" }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -130,22 +130,22 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -155,7 +155,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaHash) TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) { - static constexpr auto kOUTPUT = R"JSON({ + static constexpr auto kOutput = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -170,18 +170,18 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) })JSON"; // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 + {ripple::uint256{kIndex1}, ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -189,17 +189,17 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) // Account can receive USD 10 from Account2 and send USD 20 to Account2, now // the balance is 100, Account can only send USD to Account2 auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); // Account2 can receive JPY 10 from Account and send JPY 20 to Account, now // the balance is 100, Account2 can only send JPY to Account auto const line2 = createRippleStateLedgerObject( - "JPY", kISSUER, 100, kACCOUNT2, 10, kACCOUNT, 20, kTXN_ID, 123, 0 + "JPY", kIssuer, 100, kAccount2, 10, kAccount, 20, kTxnId, 123, 0 ); // Account can receive EUR 10 from Account and send EUR 20 to Account2, now // the balance is 8, Account can receive/send EUR to/from Account2 auto const line3 = createRippleStateLedgerObject( - "EUR", kISSUER, 8, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "EUR", kIssuer, 8, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); std::vector bbs; bbs.push_back(line1.getSerializer().peekData()); @@ -208,60 +208,60 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUTPUT)); + EXPECT_EQ(*output.result, json::parse(kOutput)); }); } TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderHash) { // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); }); } @@ -270,40 +270,40 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderSeq) { auto const ledgerSeq = 29; // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, ledgerSeq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, ledgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence(ledgerSeq, _)).WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, ledgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, ledgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, + kAccount, ledgerSeq ) ); auto const handler = AnyHandler{AccountCurrenciesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), ledgerSeq); }); diff --git a/tests/unit/rpc/handlers/AccountInfoTests.cpp b/tests/unit/rpc/handlers/AccountInfoTests.cpp index cc471dd7d..624a9b00f 100644 --- a/tests/unit/rpc/handlers/AccountInfoTests.cpp +++ b/tests/unit/rpc/handlers/AccountInfoTests.cpp @@ -31,11 +31,11 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT1 = "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount1 = "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; } // namespace @@ -129,7 +129,7 @@ INSTANTIATE_TEST_CASE_P( RPCAccountInfoGroup1, AccountInfoParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountInfoParameterTest, InvalidParams) @@ -149,7 +149,7 @@ TEST_P(AccountInfoParameterTest, InvalidParams) TEST_F(AccountInfoParameterTest, ApiV1SignerListIsNotBool) { - static constexpr auto kREQ_JSON = R"JSON( + static constexpr auto kReqJson = R"JSON( {"ident": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun", "signer_lists": 1} )JSON"; @@ -157,7 +157,7 @@ TEST_F(AccountInfoParameterTest, ApiV1SignerListIsNotBool) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(kREQ_JSON); + auto const req = json::parse(kReqJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); @@ -173,18 +173,18 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaIntSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence(30, _)) .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": 30 }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -197,18 +197,18 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaStringSequence) // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(30, _)).WillOnce(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "30" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -219,22 +219,22 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -244,23 +244,23 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaHash) TEST_F(RPCAccountInfoHandlerTest, AccountNotExist) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "actNotFound"); @@ -270,7 +270,7 @@ TEST_F(RPCAccountInfoHandlerTest, AccountNotExist) TEST_F(RPCAccountInfoHandlerTest, AccountInvalid) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // return a valid ledger object but not account root @@ -278,17 +278,17 @@ TEST_F(RPCAccountInfoHandlerTest, AccountInvalid) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "dbDeserialization"); @@ -298,12 +298,12 @@ TEST_F(RPCAccountInfoHandlerTest, AccountInvalid) TEST_F(RPCAccountInfoHandlerTest, SignerListsInvalid) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); auto signersKey = ripple::keylet::signers(account).key; @@ -317,18 +317,18 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsInvalid) .WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "signer_lists": true }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "dbDeserialization"); @@ -393,25 +393,25 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV2) "ledger_index": 30, "validated": true }})JSON", - kACCOUNT, - kINDEX1, - kACCOUNT1, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kIndex1, + kAccount1, + kAccount2, + kLedgerHash ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); auto signersKey = ripple::keylet::signers(account).key; ON_CALL(*backend_, doFetchLedgerObject(signersKey, 30, _)) .WillByDefault( - Return(createSignerLists({{kACCOUNT1, 1}, {kACCOUNT2, 1}}).getSerializer().peekData()) + Return(createSignerLists({{kAccount1, 1}, {kAccount2, 1}}).getSerializer().peekData()) ); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)) .WillOnce(Return(false)); @@ -421,18 +421,18 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV2) .WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "signer_lists": true }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(expectedOutput)); }); @@ -495,25 +495,25 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV1) "ledger_index": 30, "validated": true }})JSON", - kACCOUNT, - kINDEX1, - kACCOUNT1, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kIndex1, + kAccount1, + kAccount2, + kLedgerHash ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); auto signersKey = ripple::keylet::signers(account).key; ON_CALL(*backend_, doFetchLedgerObject(signersKey, 30, _)) .WillByDefault( - Return(createSignerLists({{kACCOUNT1, 1}, {kACCOUNT2, 1}}).getSerializer().peekData()) + Return(createSignerLists({{kAccount1, 1}, {kAccount2, 1}}).getSerializer().peekData()) ); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)) .WillOnce(Return(false)); @@ -523,18 +523,18 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV1) .WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "signer_lists": true }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 1}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 1}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(expectedOutput)); }); @@ -571,25 +571,25 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) "ledger_index": 30, "validated": true }})JSON", - kACCOUNT, - kINDEX1, - kLEDGER_HASH + kAccount, + kIndex1, + kLedgerHash ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const accountRoot = createAccountRootObject( - kACCOUNT, + kAccount, ripple::lsfDefaultRipple | ripple::lsfGlobalFreeze | ripple::lsfRequireDestTag | ripple::lsfRequireAuth | ripple::lsfDepositAuth | ripple::lsfDisableMaster | ripple::lsfDisallowXRP | ripple::lsfNoFreeze | ripple::lsfPasswordSpent, 2, 200, 2, - kINDEX1, + kIndex1, 2 ); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) @@ -602,17 +602,17 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) .WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(expectedOutput)); }); @@ -620,12 +620,12 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) TEST_F(RPCAccountInfoHandlerTest, IdentAndSignerListsFalse) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)) @@ -636,17 +636,17 @@ TEST_F(RPCAccountInfoHandlerTest, IdentAndSignerListsFalse) .WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "ident": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_FALSE(output.result->as_object().contains("signer_lists")); }); @@ -654,12 +654,12 @@ TEST_F(RPCAccountInfoHandlerTest, IdentAndSignerListsFalse) TEST_F(RPCAccountInfoHandlerTest, EmptySignerLists) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)) @@ -676,20 +676,20 @@ TEST_F(RPCAccountInfoHandlerTest, EmptySignerLists) // Once for signer object, once for keylet EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "signer_lists": true }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); auto const& resultObj = output.result->as_object(); @@ -736,18 +736,18 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) "ledger_index": 30, "validated": true }})JSON", - kACCOUNT, - kINDEX1, - kLEDGER_HASH + kAccount, + kIndex1, + kLedgerHash ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const accountRoot = createAccountRootObject( - kACCOUNT, + kAccount, ripple::lsfDefaultRipple | ripple::lsfGlobalFreeze | ripple::lsfRequireDestTag | ripple::lsfRequireAuth | ripple::lsfDepositAuth | ripple::lsfDisableMaster | ripple::lsfDisallowXRP | ripple::lsfNoFreeze | ripple::lsfPasswordSpent | @@ -756,7 +756,7 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) 2, 200, 2, - kINDEX1, + kIndex1, 2 ); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) @@ -769,17 +769,17 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) .WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(expectedOutput)); }); @@ -818,19 +818,19 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) "ledger_index": 30, "validated": true }})JSON", - kACCOUNT, - kINDEX1, - kLEDGER_HASH + kAccount, + kIndex1, + kLedgerHash ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const accountRoot = createAccountRootObject( - kACCOUNT, + kAccount, ripple::lsfDefaultRipple | ripple::lsfGlobalFreeze | ripple::lsfRequireDestTag | ripple::lsfRequireAuth | ripple::lsfDepositAuth | ripple::lsfDisableMaster | ripple::lsfDisallowXRP | ripple::lsfNoFreeze | ripple::lsfPasswordSpent | @@ -838,7 +838,7 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) 2, 200, 2, - kINDEX1, + kIndex1, 2 ); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) @@ -851,17 +851,17 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) .WillOnce(Return(true)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(expectedOutput)); }); @@ -870,10 +870,10 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) TEST(RPCAccountInfoHandlerSpecTest, DeprecatedFields) { boost::json::value const json{ - {"account", kACCOUNT}, - {"ident", kACCOUNT}, + {"account", kAccount}, + {"ident", kAccount}, {"ledger_index", 30}, - {"ledger_hash", kLEDGER_HASH}, + {"ledger_hash", kLedgerHash}, {"ledger", "some"}, {"strict", true} }; diff --git a/tests/unit/rpc/handlers/AccountLinesTests.cpp b/tests/unit/rpc/handlers/AccountLinesTests.cpp index f4fd6500f..4b5639088 100644 --- a/tests/unit/rpc/handlers/AccountLinesTests.cpp +++ b/tests/unit/rpc/handlers/AccountLinesTests.cpp @@ -31,13 +31,13 @@ using namespace testing; namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kACCOUNT3 = "rB9BMzh27F3Q6a5FtGPDayQoCCEdiRdqcK"; -constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kTXN_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount3 = "rB9BMzh27F3Q6a5FtGPDayQoCCEdiRdqcK"; +constexpr auto kIndex1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; } // namespace @@ -64,7 +64,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonHexLedgerHash) "limit": 10, "ledger_hash": "xxx" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -87,7 +87,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonStringLedgerHash) "limit": 10, "ledger_hash": 123 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -110,7 +110,7 @@ TEST_F(RPCAccountLinesHandlerTest, InvalidLedgerIndexString) "limit": 10, "ledger_index": "notvalidated" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -132,7 +132,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerNotString) "account": "{}", "marker": 9 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -157,7 +157,7 @@ TEST_F(RPCAccountLinesHandlerTest, InvalidMarker) "account": "{}", "marker": "123invalid" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -175,7 +175,7 @@ TEST_F(RPCAccountLinesHandlerTest, InvalidMarker) "account": "{}", "marker": 401 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -318,7 +318,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitZero) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -328,8 +328,8 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -356,7 +356,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerStringIndex) "account": "{}", "ledger_index": "4" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -381,7 +381,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIntIndex) "account": "{}", "ledger_index": 4 }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -399,8 +399,8 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -409,8 +409,8 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash2) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -435,7 +435,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIndex2) "account": "{}", "ledger_index": "31" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -451,8 +451,8 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIndex2) // error case account not exist TEST_F(RPCAccountLinesHandlerTest, NonExistAccount) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty @@ -464,8 +464,8 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistAccount) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -481,11 +481,11 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistAccount) // normal case when only provide account TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -495,7 +495,7 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) // return owner index containing 2 indexes ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -504,10 +504,10 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) // return two trust lines std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); auto const line2 = createRippleStateLedgerObject( - "USD", kACCOUNT, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 + "USD", kAccount, 10, kAccount2, 100, kAccount, 200, kTxnId, 123 ); bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData()); @@ -520,7 +520,7 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const correctOutput = @@ -562,11 +562,11 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) // normal case : limit is used TEST_F(RPCAccountLinesHandlerTest, UseLimit) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -580,13 +580,13 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) auto repetitions = 50; while ((repetitions--) != 0) { - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); // it should not appear in return marker,marker is the current page ownerDir.setFieldU64(ripple::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) @@ -604,7 +604,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) "account": "{}", "limit": 20 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -625,7 +625,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) "account": "{}", "limit": 9 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -640,7 +640,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) "account": "{}", "limit": 401 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{yield}); @@ -651,11 +651,11 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) // normal case : destination is used TEST_F(RPCAccountLinesHandlerTest, UseDestination) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -670,9 +670,9 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) // 10 lines to Account2 auto repetitions = 10; while ((repetitions--) != 0) { - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } @@ -680,14 +680,14 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) // 20 lines to Account3 repetitions = 20; while ((repetitions--) != 0) { - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT3, 10, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123 + "USD", kAccount3, 10, kAccount, 100, kAccount3, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -702,8 +702,8 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) "limit": 30, "peer": "{}" }})JSON", - kACCOUNT, - kACCOUNT3 + kAccount, + kAccount3 ) ); runSpawn([&, this](auto yield) { @@ -717,11 +717,11 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) // normal case : but the lines is empty TEST_F(RPCAccountLinesHandlerTest, EmptyChannel) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -730,7 +730,7 @@ TEST_F(RPCAccountLinesHandlerTest, EmptyChannel) .WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kINDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -740,7 +740,7 @@ TEST_F(RPCAccountLinesHandlerTest, EmptyChannel) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -753,7 +753,7 @@ TEST_F(RPCAccountLinesHandlerTest, EmptyChannel) TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) { - static constexpr auto kCORRECT_OUTPUT = R"JSON({ + static constexpr auto kCorrectOutput = R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -789,11 +789,11 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) ] })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -804,7 +804,7 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) // return owner index ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -813,7 +813,7 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) // return few trust lines std::vector bbs; auto line1 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 0 ); line1.setFlag(ripple::lsfHighAuth); line1.setFlag(ripple::lsfHighNoRipple); @@ -822,7 +822,7 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) bbs.push_back(line1.getSerializer().peekData()); auto line2 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 20, kACCOUNT, 200, kACCOUNT2, 400, kTXN_ID, 0 + "USD", kAccount2, 20, kAccount, 200, kAccount2, 400, kTxnId, 0 ); line2.setFlag(ripple::lsfLowAuth); line2.setFlag(ripple::lsfLowNoRipple); @@ -837,20 +837,20 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCorrectOutput), *output.result); }); } TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) { - static constexpr auto kCORRECT_OUTPUT = R"JSON({ + static constexpr auto kCorrectOutput = R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -882,11 +882,11 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) ] })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -897,7 +897,7 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) // return owner index ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -905,14 +905,14 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) // return few trust lines std::vector bbs; auto line1 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 0 ); line1.setFlag(ripple::lsfHighAuth); line1.setFlag(ripple::lsfHighFreeze); bbs.push_back(line1.getSerializer().peekData()); auto line2 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 20, kACCOUNT, 200, kACCOUNT2, 400, kTXN_ID, 0 + "USD", kAccount2, 20, kAccount, 200, kAccount2, 400, kTxnId, 0 ); line2.setFlag(ripple::lsfLowAuth); line2.setFlag(ripple::lsfLowFreeze); @@ -924,27 +924,27 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCorrectOutput), *output.result); }); } // normal case : test marker output correct TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto ownerDirKk = ripple::keylet::ownerDir(account).key; - static constexpr auto kNEXT_PAGE = 99; - static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + static constexpr auto kNextPage = 99; + static constexpr auto kLimit = 15; + auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something @@ -955,7 +955,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) std::vector bbs; auto line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 0 ); // owner dir contains 10 indexes @@ -963,7 +963,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); objectsCount--; } // return 15 objects @@ -973,12 +973,12 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + ownerDir.setFieldU64(ripple::sfIndexNext, kNextPage); // first page's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kIndex1); // second page's next page is 0 ownerDir2.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) @@ -993,8 +993,8 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); runSpawn([&, this](auto yield) { @@ -1003,7 +1003,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) ASSERT_TRUE(output); EXPECT_EQ( boost::json::value_to(output.result->as_object().at("marker")), - fmt::format("{},{}", kINDEX1, kNEXT_PAGE) + fmt::format("{},{}", kIndex1, kNextPage) ); EXPECT_EQ(output.result->as_object().at("lines").as_array().size(), 15); }); @@ -1012,12 +1012,12 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) // normal case : handler marker correctly TEST_F(RPCAccountLinesHandlerTest, MarkerInput) { - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; - static constexpr auto kNEXT_PAGE = 99; - static constexpr auto kLIMIT = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + static constexpr auto kNextPage = 99; + static constexpr auto kLimit = 15; + auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something @@ -1028,18 +1028,18 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) std::vector bbs; auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 0 ); - int objectsCount = kLIMIT; + int objectsCount = kLimit; std::vector indexes; while (objectsCount != 0) { // return owner index - indexes.emplace_back(kINDEX1); + indexes.emplace_back(kIndex1); bbs.push_back(line.getSerializer().peekData()); objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ownerDir.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -1054,10 +1054,10 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) "limit": {}, "marker": "{},{}" }})JSON", - kACCOUNT, - kLIMIT, - kINDEX1, - kNEXT_PAGE + kAccount, + kLimit, + kIndex1, + kNextPage ) ); runSpawn([&, this](auto yield) { @@ -1067,17 +1067,17 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) EXPECT_TRUE(output.result->as_object().if_contains("marker") == nullptr); // the first item is the marker itself, so the result will have limit-1 // items - EXPECT_EQ(output.result->as_object().at("lines").as_array().size(), kLIMIT - 1); + EXPECT_EQ(output.result->as_object().at("lines").as_array().size(), kLimit - 1); }); } TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -1087,7 +1087,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) // return owner index containing 2 indexes ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -1096,10 +1096,10 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) // return two trust lines std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); auto const line2 = createRippleStateLedgerObject( - "USD", kACCOUNT, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 + "USD", kAccount, 10, kAccount2, 100, kAccount, 200, kTxnId, 123 ); bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData()); @@ -1113,8 +1113,8 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountLinesHandler::kLIMIT_MIN - 1 + kAccount, + AccountLinesHandler::kLimitMin - 1 ) ); auto const correctOutput = fmt::format( @@ -1145,7 +1145,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) }} ] }})JSON", - AccountLinesHandler::kLIMIT_MIN + AccountLinesHandler::kLimitMin ); auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; @@ -1157,11 +1157,11 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something - auto account = getAccountIdWithString(kACCOUNT); + auto account = getAccountIdWithString(kAccount); auto accountKk = ripple::keylet::account(account).key; auto owneDirKk = ripple::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; @@ -1171,7 +1171,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) // return owner index containing 2 indexes ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -1180,10 +1180,10 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) // return two trust lines std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); auto const line2 = createRippleStateLedgerObject( - "USD", kACCOUNT, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 + "USD", kAccount, 10, kAccount2, 100, kAccount, 200, kTxnId, 123 ); bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData()); @@ -1197,8 +1197,8 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountLinesHandler::kLIMIT_MAX + 1 + kAccount, + AccountLinesHandler::kLimitMax + 1 ) ); auto const correctOutput = fmt::format( @@ -1229,7 +1229,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) }} ] }})JSON", - AccountLinesHandler::kLIMIT_MAX + AccountLinesHandler::kLimitMax ); auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; diff --git a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp index 1421c5086..7646d4a2e 100644 --- a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp @@ -34,31 +34,29 @@ using namespace testing; namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kISSUANCE_INDEX1 = - "A6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kISSUANCE_INDEX2 = - "B6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kIssuanceIndeX1 = "A6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIssuanceIndeX2 = "B6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; // unique values for issuance1 -constexpr uint64_t kISSUANCE1_MAX_AMOUNT = 10000; -constexpr uint64_t kISSUANCE1_OUTSTANDING_AMOUNT = 5000; -constexpr uint8_t kISSUANCE1_ASSET_SCALE = 2; -constexpr uint16_t kISSUANCE1_TRANSFER_FEE = 10; +constexpr uint64_t kIssuancE1MaxAmount = 10000; +constexpr uint64_t kIssuancE1OutstandingAmount = 5000; +constexpr uint8_t kIssuancE1AssetScale = 2; +constexpr uint16_t kIssuancE1TransferFee = 10; // unique values for issuance2 -constexpr uint64_t kISSUANCE2_MAX_AMOUNT = 20000; -constexpr uint64_t kISSUANCE2_OUTSTANDING_AMOUNT = 800; -constexpr uint64_t kISSUANCE2_LOCKED_AMOUNT = 100; -constexpr uint16_t kISSUANCE2_TRANSFER_FEE = 5; -constexpr auto kISSUANCE2_METADATA = "test-meta"; -constexpr auto kISSUANCE2_METADATA_HEX = "746573742D6D657461"; -constexpr auto kISSUANCE2_DOMAIN_ID_HEX = +constexpr uint64_t kIssuancE2MaxAmount = 20000; +constexpr uint64_t kIssuancE2OutstandingAmount = 800; +constexpr uint64_t kIssuancE2LockedAmount = 100; +constexpr uint16_t kIssuancE2TransferFee = 5; +constexpr auto kIssuancE2Metadata = "test-meta"; +constexpr auto kIssuancE2MetadataHex = "746573742D6D657461"; +constexpr auto kIssuancE2DomainIdHex = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; // define expected JSON for mpt issuances -auto const kISSUANCE_OUT1 = fmt::format( +auto const kIssuanceOuT1 = fmt::format( R"JSON({{ "mpt_issuance_id": "{}", "issuer": "{}", @@ -71,14 +69,14 @@ auto const kISSUANCE_OUT1 = fmt::format( "mpt_require_auth": true, "mpt_can_transfer": true }})JSON", - kISSUANCE_INDEX1, - kACCOUNT, - kISSUANCE1_MAX_AMOUNT, - kISSUANCE1_OUTSTANDING_AMOUNT, - kISSUANCE1_ASSET_SCALE + kIssuanceIndeX1, + kAccount, + kIssuancE1MaxAmount, + kIssuancE1OutstandingAmount, + kIssuancE1AssetScale ); -auto const kISSUANCE_OUT2 = fmt::format( +auto const kIssuanceOuT2 = fmt::format( R"JSON({{ "mpt_issuance_id": "{}", "issuer": "{}", @@ -93,14 +91,14 @@ auto const kISSUANCE_OUT2 = fmt::format( "mpt_locked": true, "mpt_can_clawback": true }})JSON", - kISSUANCE_INDEX2, - kACCOUNT, - kISSUANCE2_MAX_AMOUNT, - kISSUANCE2_OUTSTANDING_AMOUNT, - kISSUANCE2_LOCKED_AMOUNT, - kISSUANCE2_TRANSFER_FEE, - kISSUANCE2_METADATA_HEX, - kISSUANCE2_DOMAIN_ID_HEX + kIssuanceIndeX2, + kAccount, + kIssuancE2MaxAmount, + kIssuancE2OutstandingAmount, + kIssuancE2LockedAmount, + kIssuancE2TransferFee, + kIssuancE2MetadataHex, + kIssuancE2DomainIdHex ); } // namespace @@ -130,26 +128,26 @@ generateTestValuesForInvalidParamsTest() return std::vector{ {.testName = "NonHexLedgerHash", .testJson = - fmt::format(R"JSON({{ "account": "{}", "ledger_hash": "xxx" }})JSON", kACCOUNT), + fmt::format(R"JSON({{ "account": "{}", "ledger_hash": "xxx" }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "ledger_hashMalformed"}, {.testName = "NonStringLedgerHash", - .testJson = fmt::format(R"JSON({{ "account": "{}", "ledger_hash": 123 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "ledger_hash": 123 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "ledger_hashNotString"}, {.testName = "InvalidLedgerIndexString", .testJson = fmt::format( - R"JSON({{ "account": "{}", "ledger_index": "notvalidated" }})JSON", kACCOUNT + R"JSON({{ "account": "{}", "ledger_index": "notvalidated" }})JSON", kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "ledgerIndexMalformed"}, {.testName = "MarkerNotString", - .testJson = fmt::format(R"JSON({{ "account": "{}", "marker": 9 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "marker": 9 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "markerNotString"}, {.testName = "InvalidMarkerContent", .testJson = - fmt::format(R"JSON({{ "account": "{}", "marker": "123invalid" }})JSON", kACCOUNT), + fmt::format(R"JSON({{ "account": "{}", "marker": "123invalid" }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Malformed cursor."}, {.testName = "AccountMissing", @@ -165,19 +163,19 @@ generateTestValuesForInvalidParamsTest() .expectedError = "actMalformed", .expectedErrorMessage = "Account malformed."}, {.testName = "LimitNotInteger", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": "t" }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": "t" }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."}, {.testName = "LimitNegative", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": -1 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": -1 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."}, {.testName = "LimitZero", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": 0 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": 0 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."}, {.testName = "LimitTypeInvalid", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": true }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": true }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."} }; @@ -187,7 +185,7 @@ INSTANTIATE_TEST_SUITE_P( RPCAccountMPTokenIssuancesInvalidParamsGroup, AccountMPTokenIssuancesParameterTest, ValuesIn(generateTestValuesForInvalidParamsTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); // test invalid params bundle @@ -210,7 +208,7 @@ TEST_P(AccountMPTokenIssuancesParameterTest, InvalidParams) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(std::optional{})); auto const input = json::parse( @@ -219,8 +217,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -247,7 +245,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerStringIndex "account": "{}", "ledger_index": "4" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -273,7 +271,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) "account": "{}", "ledger_index": 4 }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -289,8 +287,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) // ledger not found via hash (seq > max) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 31); + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); auto const input = json::parse( fmt::format( @@ -298,8 +296,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -322,7 +320,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex) "account": "{}", "ledger_index": "31" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -338,8 +336,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex) // account not exist TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); // fetch account object return empty EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); @@ -350,8 +348,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -367,11 +365,11 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount) // fetch mptoken issuances via account successfully TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // return non-empty account - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) @@ -379,7 +377,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) // return two mptoken issuance objects ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + {ripple::uint256{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -387,30 +385,30 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) // mocking mptoken issuance ledger objects auto const bbs = std::vector{ createMptIssuanceObject( - kACCOUNT, + kAccount, 1, std::nullopt, ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow, - kISSUANCE1_OUTSTANDING_AMOUNT, + kIssuancE1OutstandingAmount, std::nullopt, - kISSUANCE1_ASSET_SCALE, - kISSUANCE1_MAX_AMOUNT + kIssuancE1AssetScale, + kIssuancE1MaxAmount ) .getSerializer() .peekData(), createMptIssuanceObject( - kACCOUNT, + kAccount, 2, - kISSUANCE2_METADATA, + kIssuancE2Metadata, ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, - kISSUANCE2_OUTSTANDING_AMOUNT, - kISSUANCE2_TRANSFER_FEE, + kIssuancE2OutstandingAmount, + kIssuancE2TransferFee, std::nullopt, - kISSUANCE2_MAX_AMOUNT, - kISSUANCE2_LOCKED_AMOUNT, - kISSUANCE2_DOMAIN_ID_HEX + kIssuancE2MaxAmount, + kIssuancE2LockedAmount, + kIssuancE2DomainIdHex ) .getSerializer() .peekData() @@ -431,13 +429,13 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) {} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - AccountMPTokenIssuancesHandler::kLIMIT_DEFAULT, - kISSUANCE_OUT1, - kISSUANCE_OUT2 + kAccount, + kLedgerHash, + AccountMPTokenIssuancesHandler::kLimitDefault, + kIssuanceOuT1, + kIssuanceOuT2 ); - auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT)); + auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kAccount)); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); @@ -448,27 +446,27 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) { - constexpr int kLIMIT = 20; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + constexpr int kLimit = 20; + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const indexes = std::vector(50, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(50, ripple::uint256{kIssuanceIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); for (int i = 0; i < 50; ++i) { - v.push_back(createMptIssuanceObject(kACCOUNT, i).getSerializer().peekData()); + v.push_back(createMptIssuanceObject(kAccount, i).getSerializer().peekData()); } return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); ownerDir.setFieldU64(ripple::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -477,15 +475,15 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(3); - runSpawn([this, kLIMIT](auto yield) { + runSpawn([this, kLimit](auto yield) { auto const input = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); @@ -494,7 +492,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) ASSERT_TRUE(output); auto const resultJson = output.result->as_object(); - EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLIMIT); + EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLimit); ASSERT_TRUE(resultJson.contains("marker")); EXPECT_THAT(boost::json::value_to(resultJson.at("marker")), EndsWith(",0")); }); @@ -507,15 +505,15 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokenIssuancesHandler::kLIMIT_MIN - 1 + kAccount, + AccountMPTokenIssuancesHandler::kLimitMin - 1 ) ); auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ( output.result->as_object().at("limit").as_uint64(), - AccountMPTokenIssuancesHandler::kLIMIT_MIN + AccountMPTokenIssuancesHandler::kLimitMin ); }); @@ -527,67 +525,66 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokenIssuancesHandler::kLIMIT_MAX + 1 + kAccount, + AccountMPTokenIssuancesHandler::kLimitMax + 1 ) ); auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ( output.result->as_object().at("limit").as_uint64(), - AccountMPTokenIssuancesHandler::kLIMIT_MAX + AccountMPTokenIssuancesHandler::kLimitMax ); }); } TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput) { - constexpr auto kNEXT_PAGE = 99; - constexpr auto kLIMIT = 15; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + constexpr auto kNextPage = 99; + constexpr auto kLimit = 15; + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const ownerDir2Kk = - ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const indexes = std::vector(10, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(10, ripple::uint256{kIssuanceIndeX1}); auto const bbs = [&]() { std::vector v; - v.reserve(kLIMIT); - for (int i = 0; i < kLIMIT; ++i) { - v.push_back(createMptIssuanceObject(kACCOUNT, i).getSerializer().peekData()); + v.reserve(kLimit); + for (int i = 0; i < kLimit; ++i) { + v.push_back(createMptIssuanceObject(kAccount, i).getSerializer().peekData()); } return v; }(); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); // mock the first directory page - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); + ownerDir1.setFieldU64(ripple::sfIndexNext, kNextPage); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); // mock the second directory page - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX2); + ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kIssuanceIndeX2); ownerDir2.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); - runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { + runSpawn([this, kLimit, kNextPage](auto yield) { auto const input = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -596,45 +593,45 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput) auto const& resultJson = output.result->as_object(); EXPECT_EQ( boost::json::value_to(resultJson.at("marker")), - fmt::format("{},{}", kISSUANCE_INDEX1, kNEXT_PAGE) + fmt::format("{},{}", kIssuanceIndeX1, kNextPage) ); - EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLIMIT); + EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLimit); }); } TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) { - constexpr auto kNEXT_PAGE = 99; - constexpr auto kLIMIT = 15; + constexpr auto kNextPage = 99; + constexpr auto kLimit = 15; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - auto const ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const indexes = std::vector(kLIMIT, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(kLimit, ripple::uint256{kIssuanceIndeX1}); auto const bbs = [&]() { std::vector v; - v.reserve(kLIMIT); - for (int i = 0; i < kLIMIT; ++i) { - v.push_back(createMptIssuanceObject(kACCOUNT, i).getSerializer().peekData()); + v.reserve(kLimit); + for (int i = 0; i < kLimit; ++i) { + v.push_back(createMptIssuanceObject(kAccount, i).getSerializer().peekData()); } return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); ownerDir.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { + runSpawn([this, kLimit, kNextPage](auto yield) { auto const input = json::parse( fmt::format( R"JSON({{ @@ -642,10 +639,10 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) "limit": {}, "marker": "{},{}" }})JSON", - kACCOUNT, - kLIMIT, - kISSUANCE_INDEX1, - kNEXT_PAGE + kAccount, + kLimit, + kIssuanceIndeX1, + kNextPage ) ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -654,53 +651,53 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) auto const& resultJson = output.result->as_object(); EXPECT_TRUE(resultJson.if_contains("marker") == nullptr); - EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLIMIT - 1); + EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLimit - 1); }); } TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + {ripple::uint256{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMptIssuanceObject( - kACCOUNT, + kAccount, 1, std::nullopt, ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow, - kISSUANCE1_OUTSTANDING_AMOUNT, + kIssuancE1OutstandingAmount, std::nullopt, - kISSUANCE1_ASSET_SCALE, - kISSUANCE1_MAX_AMOUNT + kIssuancE1AssetScale, + kIssuancE1MaxAmount ) .getSerializer() .peekData(), createMptIssuanceObject( - kACCOUNT, + kAccount, 2, - kISSUANCE2_METADATA, + kIssuancE2Metadata, ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, - kISSUANCE2_OUTSTANDING_AMOUNT, - kISSUANCE2_TRANSFER_FEE, + kIssuancE2OutstandingAmount, + kIssuancE2TransferFee, std::nullopt, - kISSUANCE2_MAX_AMOUNT, - kISSUANCE2_LOCKED_AMOUNT, - kISSUANCE2_DOMAIN_ID_HEX + kIssuancE2MaxAmount, + kIssuancE2LockedAmount, + kIssuancE2DomainIdHex ) .getSerializer() .peekData() @@ -715,8 +712,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokenIssuancesHandler::kLIMIT_MIN - 1 + kAccount, + AccountMPTokenIssuancesHandler::kLimitMin - 1 ) ); @@ -732,11 +729,11 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) {} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - AccountMPTokenIssuancesHandler::kLIMIT_MIN, - kISSUANCE_OUT1, - kISSUANCE_OUT2 + kAccount, + kLedgerHash, + AccountMPTokenIssuancesHandler::kLimitMin, + kIssuanceOuT1, + kIssuanceOuT2 ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -748,47 +745,47 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + {ripple::uint256{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMptIssuanceObject( - kACCOUNT, + kAccount, 1, std::nullopt, ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow, - kISSUANCE1_OUTSTANDING_AMOUNT, + kIssuancE1OutstandingAmount, std::nullopt, - kISSUANCE1_ASSET_SCALE, - kISSUANCE1_MAX_AMOUNT + kIssuancE1AssetScale, + kIssuancE1MaxAmount ) .getSerializer() .peekData(), createMptIssuanceObject( - kACCOUNT, + kAccount, 2, - kISSUANCE2_METADATA, + kIssuancE2Metadata, ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, - kISSUANCE2_OUTSTANDING_AMOUNT, - kISSUANCE2_TRANSFER_FEE, + kIssuancE2OutstandingAmount, + kIssuancE2TransferFee, std::nullopt, - kISSUANCE2_MAX_AMOUNT, - kISSUANCE2_LOCKED_AMOUNT, - kISSUANCE2_DOMAIN_ID_HEX + kIssuancE2MaxAmount, + kIssuancE2LockedAmount, + kIssuancE2DomainIdHex ) .getSerializer() .peekData() @@ -803,8 +800,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokenIssuancesHandler::kLIMIT_MAX + 1 + kAccount, + AccountMPTokenIssuancesHandler::kLimitMax + 1 ) ); @@ -820,11 +817,11 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) {} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - AccountMPTokenIssuancesHandler::kLIMIT_MAX, - kISSUANCE_OUT1, - kISSUANCE_OUT2 + kAccount, + kLedgerHash, + AccountMPTokenIssuancesHandler::kLimitMax, + kIssuanceOuT1, + kIssuanceOuT2 ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -836,16 +833,16 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, EmptyResult) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kISSUANCE_INDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kIssuanceIndeX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -855,7 +852,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, EmptyResult) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -875,29 +872,29 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) ripple::lsmfMPTCanMutateCanClawback | ripple::lsmfMPTCanMutateMetadata | ripple::lsmfMPTCanMutateTransferFee; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + {ripple::uint256{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMptIssuanceObject( - kACCOUNT, + kAccount, 3, std::nullopt, ripple::lsfMPTCanTransfer, - kISSUANCE1_OUTSTANDING_AMOUNT, - kISSUANCE1_TRANSFER_FEE, + kIssuancE1OutstandingAmount, + kIssuancE1TransferFee, std::nullopt, std::nullopt, std::nullopt, @@ -908,12 +905,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) .peekData(), createMptIssuanceObject( - kACCOUNT, + kAccount, 5, - kISSUANCE2_METADATA, + kIssuancE2Metadata, ripple::lsfMPTCanTransfer, - kISSUANCE2_OUTSTANDING_AMOUNT, - kISSUANCE2_TRANSFER_FEE, + kIssuancE2OutstandingAmount, + kIssuancE2TransferFee, std::nullopt, std::nullopt, std::nullopt, @@ -932,7 +929,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); @@ -971,17 +968,17 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) }} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - kISSUANCE_INDEX1, - kACCOUNT, - kISSUANCE1_OUTSTANDING_AMOUNT, - kISSUANCE1_TRANSFER_FEE, - kISSUANCE_INDEX2, - kACCOUNT, - kISSUANCE2_OUTSTANDING_AMOUNT, - kISSUANCE2_TRANSFER_FEE, - kISSUANCE2_METADATA_HEX + kAccount, + kLedgerHash, + kIssuanceIndeX1, + kAccount, + kIssuancE1OutstandingAmount, + kIssuancE1TransferFee, + kIssuanceIndeX2, + kAccount, + kIssuancE2OutstandingAmount, + kIssuancE2TransferFee, + kIssuancE2MetadataHex ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -1028,29 +1025,29 @@ INSTANTIATE_TEST_SUITE_P( RPCAccountMPTokenIssuancesImmutableFlagsGroup, AccountMPTokenIssuancesImmutableFlagsTest, ValuesIn(generateSingleFlagTests()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleFlag) { auto const testParams = GetParam(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIssuanceIndeX1}}, kIssuanceIndeX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = - std::vector{createMptIssuanceObject(kACCOUNT, 1, std::nullopt, testParams.flag, 0) + std::vector{createMptIssuanceObject(kAccount, 1, std::nullopt, testParams.flag, 0) .getSerializer() .peekData()}; @@ -1062,7 +1059,7 @@ TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleFlag) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; @@ -1123,29 +1120,29 @@ INSTANTIATE_TEST_SUITE_P( RPCAccountMPTokenIssuancesMutableFlagsGroup, AccountMPTokenIssuancesMutableFlagsTest, ValuesIn(generateSingleMutableFlagTests()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountMPTokenIssuancesMutableFlagsTest, SingleMutableFlag) { auto const testParams = GetParam(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIssuanceIndeX1}}, kIssuanceIndeX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{createMptIssuanceObject( - kACCOUNT, + kAccount, 1, std::nullopt, 0, @@ -1168,7 +1165,7 @@ TEST_P(AccountMPTokenIssuancesMutableFlagsTest, SingleMutableFlag) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; diff --git a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp index eb9e19955..c332b2960 100644 --- a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp @@ -32,18 +32,18 @@ using namespace testing; namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kISSUANCE_ID_HEX = "00080000B43A1A953EADDB3314A73523789947C752044C49"; -constexpr auto kTOKEN_INDEX1 = "A6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kTOKEN_INDEX2 = "B6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kIssuanceIdHex = "00080000B43A1A953EADDB3314A73523789947C752044C49"; +constexpr auto kTokenIndeX1 = "A6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kTokenIndeX2 = "B6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr uint64_t kTOKEN1_AMOUNT = 500; -constexpr uint64_t kTOKEN1_LOCKED_AMOUNT = 50; -constexpr uint64_t kTOKEN2_AMOUNT = 250; +constexpr uint64_t kTokeN1Amount = 500; +constexpr uint64_t kTokeN1LockedAmount = 50; +constexpr uint64_t kTokeN2Amount = 250; // define expected JSON for mptokens -auto const kTOKEN_OUT1 = fmt::format( +auto const kTokenOuT1 = fmt::format( R"JSON({{ "mpt_id": "{}", "account": "{}", @@ -52,14 +52,14 @@ auto const kTOKEN_OUT1 = fmt::format( "locked_amount": {}, "mpt_locked": true }})JSON", - kTOKEN_INDEX1, - kACCOUNT, - kISSUANCE_ID_HEX, - kTOKEN1_AMOUNT, - kTOKEN1_LOCKED_AMOUNT + kTokenIndeX1, + kAccount, + kIssuanceIdHex, + kTokeN1Amount, + kTokeN1LockedAmount ); -auto const kTOKEN_OUT2 = fmt::format( +auto const kTokenOuT2 = fmt::format( R"JSON({{ "mpt_id": "{}", "account": "{}", @@ -67,10 +67,10 @@ auto const kTOKEN_OUT2 = fmt::format( "mpt_amount": {}, "mpt_authorized": true }})JSON", - kTOKEN_INDEX2, - kACCOUNT, - kISSUANCE_ID_HEX, - kTOKEN2_AMOUNT + kTokenIndeX2, + kAccount, + kIssuanceIdHex, + kTokeN2Amount ); } // namespace @@ -99,26 +99,26 @@ generateTestValuesForInvalidParamsTest() return std::vector{ {.testName = "NonHexLedgerHash", .testJson = - fmt::format(R"JSON({{ "account": "{}", "ledger_hash": "xxx" }})JSON", kACCOUNT), + fmt::format(R"JSON({{ "account": "{}", "ledger_hash": "xxx" }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "ledger_hashMalformed"}, {.testName = "NonStringLedgerHash", - .testJson = fmt::format(R"JSON({{ "account": "{}", "ledger_hash": 123 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "ledger_hash": 123 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "ledger_hashNotString"}, {.testName = "InvalidLedgerIndexString", .testJson = fmt::format( - R"JSON({{ "account": "{}", "ledger_index": "notvalidated" }})JSON", kACCOUNT + R"JSON({{ "account": "{}", "ledger_index": "notvalidated" }})JSON", kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "ledgerIndexMalformed"}, {.testName = "MarkerNotString", - .testJson = fmt::format(R"JSON({{ "account": "{}", "marker": 9 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "marker": 9 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "markerNotString"}, {.testName = "InvalidMarkerContent", .testJson = - fmt::format(R"JSON({{ "account": "{}", "marker": "123invalid" }})JSON", kACCOUNT), + fmt::format(R"JSON({{ "account": "{}", "marker": "123invalid" }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Malformed cursor."}, {.testName = "AccountMissing", @@ -135,19 +135,19 @@ generateTestValuesForInvalidParamsTest() .expectedError = "actMalformed", .expectedErrorMessage = "Account malformed."}, {.testName = "LimitNotInteger", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": "t" }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": "t" }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."}, {.testName = "LimitNegative", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": -1 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": -1 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."}, {.testName = "LimitZero", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": 0 }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": 0 }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."}, {.testName = "LimitTypeInvalid", - .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": true }})JSON", kACCOUNT), + .testJson = fmt::format(R"JSON({{ "account": "{}", "limit": true }})JSON", kAccount), .expectedError = "invalidParams", .expectedErrorMessage = "Invalid parameters."} }; @@ -157,7 +157,7 @@ INSTANTIATE_TEST_SUITE_P( RPCAccountMPTokensInvalidParamsGroup, AccountMPTokensParameterTest, ValuesIn(generateTestValuesForInvalidParamsTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); // test invalid params bundle @@ -178,7 +178,7 @@ TEST_P(AccountMPTokensParameterTest, InvalidParams) TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash to return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(std::optional{})); auto const input = json::parse( @@ -187,8 +187,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -214,7 +214,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerStringIndex) "account": "{}", "ledger_index": "4" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -239,7 +239,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) "account": "{}", "ledger_index": 4 }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -254,8 +254,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByHash) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 31); + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); auto const input = json::parse( @@ -264,8 +264,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -289,7 +289,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex) "account": "{}", "ledger_index": "31" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -304,8 +304,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); // fetch account object return empty EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); @@ -316,8 +316,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); @@ -333,36 +333,36 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount) TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 + {ripple::uint256{kTokenIndeX1}, ripple::uint256{kTokenIndeX2}}, kTokenIndeX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMpTokenObject( - kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), - kTOKEN1_AMOUNT, + kAccount, + ripple::uint192(kIssuanceIdHex), + kTokeN1Amount, ripple::lsfMPTLocked, - kTOKEN1_LOCKED_AMOUNT + kTokeN1LockedAmount ) .getSerializer() .peekData(), createMpTokenObject( - kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), - kTOKEN2_AMOUNT, + kAccount, + ripple::uint192(kIssuanceIdHex), + kTokeN2Amount, ripple::lsfMPTAuthorized, std::nullopt ) @@ -385,13 +385,13 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) {} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - AccountMPTokensHandler::kLIMIT_DEFAULT, - kTOKEN_OUT1, - kTOKEN_OUT2 + kAccount, + kLedgerHash, + AccountMPTokensHandler::kLimitDefault, + kTokenOuT1, + kTokenOuT2 ); - auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT)); + auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kAccount)); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); @@ -401,23 +401,23 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) { - constexpr int kLIMIT = 20; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + constexpr int kLimit = 20; + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const indexes = std::vector(50, ripple::uint256{kTOKEN_INDEX1}); + auto const indexes = std::vector(50, ripple::uint256{kTokenIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); for (int i = 0; i < 50; ++i) { v.push_back( - createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + createMpTokenObject(kAccount, ripple::uint192(kIssuanceIdHex), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -425,7 +425,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTokenIndeX1); ownerDir.setFieldU64(ripple::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -434,15 +434,15 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(3); - runSpawn([this, kLIMIT](auto yield) { + runSpawn([this, kLimit](auto yield) { auto const input = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); @@ -451,7 +451,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) ASSERT_TRUE(output); auto const resultJson = output.result->as_object(); - EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLIMIT); + EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLimit); ASSERT_TRUE(resultJson.contains("marker")); EXPECT_THAT(boost::json::value_to(resultJson.at("marker")), EndsWith(",0")); }); @@ -463,8 +463,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokensHandler::kLIMIT_MIN - 1 + kAccount, + AccountMPTokensHandler::kLimitMin - 1 ) ); @@ -472,7 +472,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ( - output.result->as_object().at("limit").as_uint64(), AccountMPTokensHandler::kLIMIT_MIN + output.result->as_object().at("limit").as_uint64(), AccountMPTokensHandler::kLimitMin ); }); @@ -483,8 +483,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokensHandler::kLIMIT_MAX + 1 + kAccount, + AccountMPTokensHandler::kLimitMax + 1 ) ); @@ -492,32 +492,31 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ( - output.result->as_object().at("limit").as_uint64(), AccountMPTokensHandler::kLIMIT_MAX + output.result->as_object().at("limit").as_uint64(), AccountMPTokensHandler::kLimitMax ); }); } TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) { - constexpr auto kNEXT_PAGE = 99; - constexpr auto kLIMIT = 15; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + constexpr auto kNextPage = 99; + constexpr auto kLimit = 15; + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const ownerDir2Kk = - ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const bbs = [&]() { std::vector v; - v.reserve(kLIMIT); - for (int i = 0; i < kLIMIT; ++i) { + v.reserve(kLimit); + for (int i = 0; i < kLimit; ++i) { v.push_back( - createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + createMpTokenObject(kAccount, ripple::uint192(kIssuanceIdHex), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -529,63 +528,63 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) std::vector indexes1; indexes1.reserve(10); for (int i = 0; i < 10; ++i) { - indexes1.emplace_back(kTOKEN_INDEX1); + indexes1.emplace_back(kTokenIndeX1); } - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTokenIndeX1); + ownerDir1.setFieldU64(ripple::sfIndexNext, kNextPage); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX2); + ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTokenIndeX2); ownerDir2.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { + runSpawn([this, kLimit, kNextPage](auto yield) { auto const input = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); auto const& resultJson = output.result->as_object(); - EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLIMIT); + EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLimit); EXPECT_EQ( boost::json::value_to(resultJson.at("marker")), - fmt::format("{},{}", kTOKEN_INDEX1, kNEXT_PAGE) + fmt::format("{},{}", kTokenIndeX1, kNextPage) ); }); } TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) { - constexpr auto kNEXT_PAGE = 99; - constexpr auto kLIMIT = 15; + constexpr auto kNextPage = 99; + constexpr auto kLimit = 15; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; - auto const indexes = std::vector(kLIMIT, ripple::uint256{kTOKEN_INDEX1}); + auto const indexes = std::vector(kLimit, ripple::uint256{kTokenIndeX1}); auto const bbs = [&]() { std::vector v; - v.reserve(kLIMIT); - for (int i = 0; i < kLIMIT; ++i) { + v.reserve(kLimit); + for (int i = 0; i < kLimit; ++i) { v.push_back( - createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + createMpTokenObject(kAccount, ripple::uint192(kIssuanceIdHex), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -593,7 +592,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); + ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTokenIndeX1); ownerDir.setFieldU64(ripple::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -601,7 +600,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { + runSpawn([this, kLimit, kNextPage](auto yield) { auto const input = json::parse( fmt::format( R"JSON({{ @@ -609,10 +608,10 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) "limit": {}, "marker": "{},{}" }})JSON", - kACCOUNT, - kLIMIT, - kTOKEN_INDEX1, - kNEXT_PAGE + kAccount, + kLimit, + kTokenIndeX1, + kNextPage ) ); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; @@ -620,42 +619,42 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) ASSERT_TRUE(output); auto const& resultJson = output.result->as_object(); EXPECT_TRUE(resultJson.if_contains("marker") == nullptr); - EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLIMIT - 1); + EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLimit - 1); }); } TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 + {ripple::uint256{kTokenIndeX1}, ripple::uint256{kTokenIndeX2}}, kTokenIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMpTokenObject( - kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), - kTOKEN1_AMOUNT, + kAccount, + ripple::uint192(kIssuanceIdHex), + kTokeN1Amount, ripple::lsfMPTLocked, - kTOKEN1_LOCKED_AMOUNT + kTokeN1LockedAmount ) .getSerializer() .peekData(), createMpTokenObject( - kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), - kTOKEN2_AMOUNT, + kAccount, + ripple::uint192(kIssuanceIdHex), + kTokeN2Amount, ripple::lsfMPTAuthorized, std::nullopt ) @@ -672,8 +671,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokensHandler::kLIMIT_MIN - 1 + kAccount, + AccountMPTokensHandler::kLimitMin - 1 ) ); @@ -689,11 +688,11 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) {} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - AccountMPTokensHandler::kLIMIT_MIN, - kTOKEN_OUT1, - kTOKEN_OUT2 + kAccount, + kLedgerHash, + AccountMPTokensHandler::kLimitMin, + kTokenOuT1, + kTokenOuT2 ); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; @@ -705,36 +704,36 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 + {ripple::uint256{kTokenIndeX1}, ripple::uint256{kTokenIndeX2}}, kTokenIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMpTokenObject( - kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), - kTOKEN1_AMOUNT, + kAccount, + ripple::uint192(kIssuanceIdHex), + kTokeN1Amount, ripple::lsfMPTLocked, - kTOKEN1_LOCKED_AMOUNT + kTokeN1LockedAmount ) .getSerializer() .peekData(), createMpTokenObject( - kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), - kTOKEN2_AMOUNT, + kAccount, + ripple::uint192(kIssuanceIdHex), + kTokeN2Amount, ripple::lsfMPTAuthorized, std::nullopt ) @@ -751,8 +750,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountMPTokensHandler::kLIMIT_MAX + 1 + kAccount, + AccountMPTokensHandler::kLimitMax + 1 ) ); @@ -768,11 +767,11 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) {} ] }})JSON", - kACCOUNT, - kLEDGER_HASH, - AccountMPTokensHandler::kLIMIT_MAX, - kTOKEN_OUT1, - kTOKEN_OUT2 + kAccount, + kLedgerHash, + AccountMPTokensHandler::kLimitMax, + kTokenOuT1, + kTokenOuT2 ); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; @@ -784,16 +783,16 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) TEST_F(RPCAccountMPTokensHandlerTest, EmptyResult) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; auto const owneDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kTOKEN_INDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kTokenIndeX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -803,7 +802,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, EmptyResult) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; diff --git a/tests/unit/rpc/handlers/AccountNFTsTests.cpp b/tests/unit/rpc/handlers/AccountNFTsTests.cpp index d59046140..32b20a35c 100644 --- a/tests/unit/rpc/handlers/AccountNFTsTests.cpp +++ b/tests/unit/rpc/handlers/AccountNFTsTests.cpp @@ -23,18 +23,18 @@ namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kTOKEN_ID = "000827103B94ECBB7BF0A0A6ED62B3607801A27B65F4679F4AD1D4850000C0EA"; -constexpr auto kISSUER = "raSsG8F6KePke7sqw2MXYZ3mu7p68GvFma"; -constexpr auto kSERIAL = 49386; -constexpr auto kTAX_ON = 0; -constexpr auto kFLAG = 8; -constexpr auto kTXN_ID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kPAGE = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kINVALID_PAGE = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FCAAA"; -constexpr auto kMAX_SEQ = 30; -constexpr auto kMIN_SEQ = 10; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kTokenId = "000827103B94ECBB7BF0A0A6ED62B3607801A27B65F4679F4AD1D4850000C0EA"; +constexpr auto kIssuer = "raSsG8F6KePke7sqw2MXYZ3mu7p68GvFma"; +constexpr auto kSerial = 49386; +constexpr auto kTaxOn = 0; +constexpr auto kFlag = 8; +constexpr auto kTxnId = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kPage = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kInvalidPage = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FCAAA"; +constexpr auto kMaxSeq = 30; +constexpr auto kMinSeq = 10; } // namespace @@ -46,7 +46,7 @@ using namespace testing; struct RPCAccountNFTsHandlerTest : HandlerBaseTest { RPCAccountNFTsHandlerTest() { - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); } }; @@ -144,7 +144,7 @@ INSTANTIATE_TEST_CASE_P( RPCAccountNFTsGroup1, AccountNFTParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountNFTParameterTest, InvalidParams) @@ -165,22 +165,22 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -190,26 +190,26 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaHash) TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaStringIndex) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)) + ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "{}" }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -219,26 +219,26 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaStringIndex) TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaIntIndex) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)) + ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -248,24 +248,24 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaIntIndex) TEST_F(RPCAccountNFTsHandlerTest, AccountNotFound) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "actNotFound"); @@ -275,7 +275,7 @@ TEST_F(RPCAccountNFTsHandlerTest, AccountNotFound) TEST_F(RPCAccountNFTsHandlerTest, NormalPath) { - static auto const kEXPECTED_OUTPUT = fmt::format( + static auto const kExpectedOutput = fmt::format( R"JSON({{ "ledger_hash": "{}", "ledger_index": 30, @@ -294,82 +294,82 @@ TEST_F(RPCAccountNFTsHandlerTest, NormalPath) ], "limit": 100 }})JSON", - kLEDGER_HASH, - kACCOUNT, - kTOKEN_ID, - kFLAG, - kISSUER, - kTAX_ON, - kSERIAL + kLedgerHash, + kAccount, + kTokenId, + kFlag, + kIssuer, + kTaxOn, + kSerial ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const firstPage = ripple::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); ON_CALL(*backend_, doFetchLedgerObject(firstPage, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } TEST_F(RPCAccountNFTsHandlerTest, Limit) { - static constexpr auto kLIMIT = 20; + static constexpr auto kLimit = 20; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const firstPage = ripple::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, firstPage + std::vector{std::make_pair(kTokenId, "www.ok.com")}, firstPage ); ON_CALL(*backend_, doFetchLedgerObject(firstPage, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1 + kLIMIT); + EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1 + kLimit); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_nfts").as_array().size(), 20); EXPECT_EQ(output.result->as_object().at("marker").as_string(), ripple::strHex(firstPage)); @@ -378,35 +378,35 @@ TEST_F(RPCAccountNFTsHandlerTest, Limit) TEST_F(RPCAccountNFTsHandlerTest, Marker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const pageObject = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAGE}, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPage}, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{}" }})JSON", - kACCOUNT, - kPAGE + kAccount, + kPage ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_nfts").as_array().size(), 1); }); @@ -414,28 +414,28 @@ TEST_F(RPCAccountNFTsHandlerTest, Marker) TEST_F(RPCAccountNFTsHandlerTest, InvalidMarker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{}" }})JSON", - kACCOUNT, - kINVALID_PAGE + kAccount, + kInvalidPage ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); @@ -447,26 +447,26 @@ TEST_F(RPCAccountNFTsHandlerTest, InvalidMarker) TEST_F(RPCAccountNFTsHandlerTest, AccountWithNoNFT) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_nfts").as_array().size(), 0); }); @@ -474,35 +474,35 @@ TEST_F(RPCAccountNFTsHandlerTest, AccountWithNoNFT) TEST_F(RPCAccountNFTsHandlerTest, invalidPage) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const pageObject = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAGE}, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPage}, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{}" }})JSON", - kACCOUNT, - kPAGE + kAccount, + kPage ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); @@ -514,7 +514,7 @@ TEST_F(RPCAccountNFTsHandlerTest, invalidPage) TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) { - static auto const kEXPECTED_OUTPUT = fmt::format( + static auto const kExpectedOutput = fmt::format( R"JSON({{ "ledger_hash": "{}", "ledger_index": 30, @@ -533,54 +533,54 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) ], "limit": {} }})JSON", - kLEDGER_HASH, - kACCOUNT, - kTOKEN_ID, - kFLAG, - kISSUER, - kTAX_ON, - kSERIAL, - AccountNFTsHandler::kLIMIT_MIN + kLedgerHash, + kAccount, + kTokenId, + kFlag, + kIssuer, + kTaxOn, + kSerial, + AccountNFTsHandler::kLimitMin ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const firstPage = ripple::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); ON_CALL(*backend_, doFetchLedgerObject(firstPage, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountNFTsHandler::kLIMIT_MIN - 1 + kAccount, + AccountNFTsHandler::kLimitMin - 1 ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) { - static auto const kEXPECTED_OUTPUT = fmt::format( + static auto const kExpectedOutput = fmt::format( R"JSON({{ "ledger_hash": "{}", "ledger_index": 30, @@ -599,47 +599,47 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) ], "limit": {} }})JSON", - kLEDGER_HASH, - kACCOUNT, - kTOKEN_ID, - kFLAG, - kISSUER, - kTAX_ON, - kSERIAL, - AccountNFTsHandler::kLIMIT_MAX + kLedgerHash, + kAccount, + kTokenId, + kFlag, + kIssuer, + kTaxOn, + kSerial, + AccountNFTsHandler::kLimitMax ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); - auto const accountID = getAccountIdWithString(kACCOUNT); + auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 3); + auto const accountID = getAccountIdWithString(kAccount); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const firstPage = ripple::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); ON_CALL(*backend_, doFetchLedgerObject(firstPage, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountNFTsHandler::kLIMIT_MAX + 1 + kAccount, + AccountNFTsHandler::kLimitMax + 1 ) ); auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } diff --git a/tests/unit/rpc/handlers/AccountObjectsTests.cpp b/tests/unit/rpc/handlers/AccountObjectsTests.cpp index dfeabe82e..95ebb79c5 100644 --- a/tests/unit/rpc/handlers/AccountObjectsTests.cpp +++ b/tests/unit/rpc/handlers/AccountObjectsTests.cpp @@ -35,22 +35,22 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kISSUER = "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kTXN_ID = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; -constexpr auto kTOKEN_ID = "000827103B94ECBB7BF0A0A6ED62B3607801A27B65F4679F4AD1D4850000C0EA"; -constexpr auto kMAX_SEQ = 30; -constexpr auto kMIN_SEQ = 10; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kIssuer = "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kTxnId = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; +constexpr auto kTokenId = "000827103B94ECBB7BF0A0A6ED62B3607801A27B65F4679F4AD1D4850000C0EA"; +constexpr auto kMaxSeq = 30; +constexpr auto kMinSeq = 10; } // namespace struct RPCAccountObjectsHandlerTest : HandlerBaseTest { RPCAccountObjectsHandlerTest() { - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); } }; @@ -191,7 +191,7 @@ INSTANTIATE_TEST_CASE_P( RPCAccountObjectsGroup1, AccountObjectsParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountObjectsParameterTest, InvalidParams) @@ -211,21 +211,21 @@ TEST_P(AccountObjectsParameterTest, InvalidParams) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaIntSequence) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)) + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)) .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": 30 }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -236,20 +236,20 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaIntSequence) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillOnce(Return(std::nullopt)); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).WillOnce(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "30" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -260,22 +260,22 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -285,22 +285,22 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaHash) TEST_F(RPCAccountObjectsHandlerTest, AccountNotExist) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "actNotFound"); @@ -310,7 +310,7 @@ TEST_F(RPCAccountObjectsHandlerTest, AccountNotExist) TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound) { - static constexpr auto kEXPECTED_OUT = R"JSON({ + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -342,15 +342,15 @@ TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound) ] })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -361,44 +361,44 @@ TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound) std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCAccountObjectsHandlerTest, Limit) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - static constexpr auto kLIMIT = 10; - auto count = kLIMIT * 2; + static constexpr auto kLimit = 10; + auto count = kLimit * 2; // put 20 items in owner dir, but only return 10 auto const ownerDir = - createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kINDEX1}), kINDEX1); + createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kIndex1}), kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -410,50 +410,50 @@ TEST_F(RPCAccountObjectsHandlerTest, Limit) std::vector bbs; while (count-- != 0) { auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - kLIMIT + kAccount, + kLimit ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kLIMIT); + EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kLimit); EXPECT_EQ( - output.result->as_object().at("marker").as_string(), fmt::format("{},{}", kINDEX1, 0) + output.result->as_object().at("marker").as_string(), fmt::format("{},{}", kIndex1, 0) ); }); } TEST_F(RPCAccountObjectsHandlerTest, Marker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - static constexpr auto kLIMIT = 20; - static constexpr auto kPAGE = 2; - auto count = kLIMIT; + static constexpr auto kLimit = 20; + static constexpr auto kPage = 2; + auto count = kLimit; auto const ownerDir = - createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kINDEX1}), kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - auto const hintIndex = ripple::keylet::page(ownerDirKk, kPAGE).key; + createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kIndex1}), kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + auto const hintIndex = ripple::keylet::page(ownerDirKk, kPage).key; EXPECT_CALL(*backend_, doFetchLedgerObject(hintIndex, 30, _)) .Times(2) .WillRepeatedly(Return(ownerDir.getSerializer().peekData())); @@ -461,51 +461,51 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker) std::vector bbs; while (count-- != 0) { auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, - kINDEX1, - kPAGE + kAccount, + kIndex1, + kPage ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kLIMIT - 1); + EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kLimit - 1); EXPECT_FALSE(output.result->as_object().contains("marker")); }); } TEST_F(RPCAccountObjectsHandlerTest, MultipleDirNoNFT) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - static constexpr auto kCOUNT = 10; - static constexpr auto kNEXTPAGE = 1; - auto cc = kCOUNT; - auto ownerDir = createOwnerDirLedgerObject(std::vector(cc, ripple::uint256{kINDEX1}), kINDEX1); + static constexpr auto kCount = 10; + static constexpr auto kNextpage = 1; + auto cc = kCount; + auto ownerDir = createOwnerDirLedgerObject(std::vector(cc, ripple::uint256{kIndex1}), kIndex1); // set next page - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXTPAGE); + ownerDir.setFieldU64(ripple::sfIndexNext, kNextpage); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const page1 = ripple::keylet::page(ownerDirKk, kNEXTPAGE).key; + auto const page1 = ripple::keylet::page(ownerDirKk, kNextpage).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(page1, 30, _)) @@ -517,50 +517,50 @@ TEST_F(RPCAccountObjectsHandlerTest, MultipleDirNoNFT) std::vector bbs; // 10 items per page, 2 pages - cc = kCOUNT * 2; + cc = kCount * 2; while (cc-- != 0) { auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - 2 * kCOUNT + kAccount, + 2 * kCount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kCOUNT * 2); + EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kCount * 2); EXPECT_EQ( output.result->as_object().at("marker").as_string(), - fmt::format("{},{}", kINDEX1, kNEXTPAGE) + fmt::format("{},{}", kIndex1, kNextpage) ); }); } TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -572,36 +572,36 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) std::vector bbs; // put 1 state and 1 offer auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(offer.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "type": "offer" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), 1); }); @@ -609,16 +609,16 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) TEST_F(RPCAccountObjectsHandlerTest, TypeFilterAmmType) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -630,29 +630,29 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterAmmType) std::vector bbs; // put 1 state and 1 amm auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); auto const ammObject = - createAmmObject(kACCOUNT, "XRP", toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2); + createAmmObject(kAccount, "XRP", toBase58(ripple::xrpAccount()), "JPY", kAccount2); bbs.push_back(ammObject.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "type": "amm" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); auto const& accountObjects = output.result->as_object().at("account_objects").as_array(); ASSERT_EQ(accountObjects.size(), 1); @@ -662,16 +662,16 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterAmmType) TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -682,36 +682,36 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(offer.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "type": "check" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), 0); }); @@ -719,17 +719,17 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -739,19 +739,19 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); std::vector bbs; @@ -761,19 +761,19 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "deletion_blockers_only": true }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), 2); }); @@ -781,16 +781,16 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -800,10 +800,10 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter) EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); std::vector bbs; bbs.push_back(line.getSerializer().peekData()); @@ -811,20 +811,20 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "deletion_blockers_only": true, "type": "payment_channel" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), 1); }); @@ -832,16 +832,16 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter) TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterEmptyResult) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -851,24 +851,24 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterEmptyResult) EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const offer1 = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); auto const offer2 = createOfferLedgerObject( - kACCOUNT, + kAccount, 20, 30, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); std::vector bbs; @@ -877,19 +877,19 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterEmptyResult) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "deletion_blockers_only": true }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), 0); }); @@ -900,16 +900,16 @@ TEST_F( DeletionBlockersOnlyFilterWithIncompatibleTypeYieldsEmptyResult ) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -918,24 +918,24 @@ TEST_F( EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const offer1 = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); auto const offer2 = createOfferLedgerObject( - kACCOUNT, + kAccount, 20, 30, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); std::vector bbs; @@ -944,20 +944,20 @@ TEST_F( EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "deletion_blockers_only": true, "type": "offer" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), 0); }); @@ -965,7 +965,7 @@ TEST_F( TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects) { - static constexpr auto kEXPECTED_OUT = R"JSON({ + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -1028,15 +1028,15 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects) ] })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1044,57 +1044,57 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects) // nft page 1 auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; auto const nftPage2KK = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kINDEX1}).key; + ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kIndex1}).key; auto const nftpage1 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, nftPage2KK + std::vector{std::make_pair(kTokenId, "www.ok.com")}, nftPage2KK ); EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)) .WillOnce(Return(nftpage1.getSerializer().peekData())); // nft page 2 , end auto const nftpage2 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); EXPECT_CALL(*backend_, doFetchLedgerObject(nftPage2KK, 30, _)) .WillOnce(Return(nftpage2.getSerializer().peekData())); std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitReturnMarker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto current = ripple::keylet::nftpage_max(account).key; - std::string first{kINDEX1}; + std::string first{kIndex1}; std::ranges::sort(first); for (auto i = 0; i < 10; i++) { std::ranges::next_permutation(first); @@ -1103,27 +1103,27 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitReturnMarker) ) .key; auto const nftpage = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous + std::vector{std::make_pair(kTokenId, "www.ok.com")}, previous ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage.getSerializer().peekData())); current = previous; } - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, + kAccount, 10 ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result.value().as_object().at("account_objects").as_array().size(), 10); EXPECT_EQ( @@ -1135,16 +1135,16 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitReturnMarker) TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto current = ripple::keylet::nftpage_max(account).key; - std::string first{kINDEX1}; + std::string first{kIndex1}; std::ranges::sort(first); for (auto i = 0; i < 10; i++) { std::ranges::next_permutation(first); @@ -1153,32 +1153,32 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) ) .key; auto const nftpage = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous + std::vector{std::make_pair(kTokenId, "www.ok.com")}, previous ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage.getSerializer().peekData())); current = previous; } auto const nftpage11 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage11.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, + kAccount, 11 ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result.value().as_object().at("account_objects").as_array().size(), 11); //"0000000000000000000000000000000000000000000000000000000000000000,4294967295" @@ -1195,15 +1195,15 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - std::string first{kINDEX1}; + std::string first{kIndex1}; auto current = ripple::keylet::nftpage( ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()} ) @@ -1217,39 +1217,39 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) ) .key; auto const nftpage = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous + std::vector{std::make_pair(kTokenId, "www.ok.com")}, previous ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage.getSerializer().peekData())); current = previous; } auto const nftpage11 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage11.getSerializer().peekData())); auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1 + {ripple::uint256{kIndex1}, ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1 ); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const line = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); std::vector bbs; @@ -1259,13 +1259,13 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, + kAccount, ripple::strHex(marker), std::numeric_limits::max() ) @@ -1273,7 +1273,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ( output.result.value().as_object().at("account_objects").as_array().size(), 11 + 3 @@ -1285,35 +1285,35 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) // when limit reached, happen to be the end of NFT page list TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1 + {ripple::uint256{kIndex1}, ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1 ); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const line = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); std::vector bbs; @@ -1323,13 +1323,13 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, + kAccount, ripple::strHex(ripple::uint256{beast::zero}), std::numeric_limits::max() ) @@ -1337,7 +1337,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result.value().as_object().at("account_objects").as_array().size(), 3); EXPECT_FALSE(output.result.value().as_object().contains("marker")); @@ -1346,29 +1346,29 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotInRange) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, - kINDEX1, + kAccount, + kIndex1, std::numeric_limits::max() ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); @@ -1378,26 +1378,26 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotInRange) TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotExist) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); // return null for this marker auto const accountNftMax = ripple::keylet::nftpage_max(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountNftMax, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountNftMax, kMaxSeq, _)) .WillOnce(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, + kAccount, ripple::strHex(accountNftMax), std::numeric_limits::max() ) @@ -1405,7 +1405,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotExist) auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); @@ -1415,15 +1415,15 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotExist) TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - std::string first{kINDEX1}; + std::string first{kIndex1}; auto current = ripple::keylet::nftpage( ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()} ) @@ -1437,38 +1437,38 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) ) .key; auto const nftpage = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous + std::vector{std::make_pair(kTokenId, "www.ok.com")}, previous ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage.getSerializer().peekData())); current = previous; } auto const nftpage11 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)) .WillOnce(Return(nftpage11.getSerializer().peekData())); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); auto const line = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); std::vector bbs; @@ -1478,14 +1478,14 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}", "limit": 12 }})JSON", - kACCOUNT, + kAccount, ripple::strHex(marker), std::numeric_limits::max() ) @@ -1493,20 +1493,20 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result.value().as_object().at("account_objects").as_array().size(), 12); // marker not in NFT "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC,0" EXPECT_EQ( output.result.value().as_object().at("marker").as_string(), - fmt::format("{},{}", kINDEX1, 0) + fmt::format("{},{}", kIndex1, 0) ); }); } TEST_F(RPCAccountObjectsHandlerTest, FilterNFT) { - static constexpr auto kEXPECTED_OUT = R"JSON({ + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -1547,15 +1547,15 @@ TEST_F(RPCAccountObjectsHandlerTest, FilterNFT) ] })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1563,61 +1563,61 @@ TEST_F(RPCAccountObjectsHandlerTest, FilterNFT) // nft page 1 auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; auto const nftPage2KK = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kINDEX1}).key; + ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kIndex1}).key; auto const nftpage1 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, nftPage2KK + std::vector{std::make_pair(kTokenId, "www.ok.com")}, nftPage2KK ); EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)) .WillOnce(Return(nftpage1.getSerializer().peekData())); // nft page 2 , end auto const nftpage2 = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ); EXPECT_CALL(*backend_, doFetchLedgerObject(nftPage2KK, 30, _)) .WillOnce(Return(nftpage2.getSerializer().peekData())); std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "type": "nft_page" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - static constexpr auto kLIMIT = 10; - auto count = kLIMIT * 2; + static constexpr auto kLimit = 10; + auto count = kLimit * 2; // put 20 items in owner dir, but only return 10 auto const ownerDir = - createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kINDEX1}), kINDEX1); + createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kIndex1}), kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1625,21 +1625,21 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) std::vector bbs; while (count-- != 0) { auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {}, "marker": "{},{}" }})JSON", - kACCOUNT, - kLIMIT, + kAccount, + kLimit, ripple::strHex(ripple::uint256{beast::zero}), std::numeric_limits::max() ) @@ -1647,18 +1647,18 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kLIMIT); + EXPECT_EQ(output.result->as_object().at("account_objects").as_array().size(), kLimit); EXPECT_EQ( - output.result->as_object().at("marker").as_string(), fmt::format("{},{}", kINDEX1, 0) + output.result->as_object().at("marker").as_string(), fmt::format("{},{}", kIndex1, 0) ); }); } TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin) { - static auto const kEXPECTED_OUT = fmt::format( + static auto const kExpectedOut = fmt::format( R"JSON({{ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -1690,18 +1690,18 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin) }} ] }})JSON", - AccountObjectsHandler::kLIMIT_MIN + AccountObjectsHandler::kLimitMin ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1712,34 +1712,34 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin) std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountObjectsHandler::kLIMIT_MIN - 1 + kAccount, + AccountObjectsHandler::kLimitMin - 1 ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax) { - static auto const kEXPECTED_OUT = fmt::format( + static auto const kExpectedOut = fmt::format( R"JSON({{ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -1771,18 +1771,18 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax) }} ] }})JSON", - AccountObjectsHandler::kLIMIT_MAX + AccountObjectsHandler::kLimitMax ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1793,42 +1793,42 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax) std::vector bbs; auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); bbs.push_back(line1.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountObjectsHandler::kLIMIT_MAX + 1 + kAccount, + AccountObjectsHandler::kLimitMax + 1 ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTIssuanceType) { - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerinfo)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1839,24 +1839,24 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTIssuanceType) std::vector bbs; // put 1 mpt issuance - auto const issuanceObject = createMptIssuanceObject(kACCOUNT, 2, "metadata"); + auto const issuanceObject = createMptIssuanceObject(kAccount, 2, "metadata"); bbs.push_back(issuanceObject.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "type": "mpt_issuance" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); auto const& accountObjects = output.result->as_object().at("account_objects").as_array(); ASSERT_EQ(accountObjects.size(), 1); @@ -1865,22 +1865,22 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTIssuanceType) // make sure mptID is synethetically parsed if object is mptIssuance EXPECT_EQ( accountObjects.front().at("mpt_issuance_id").as_string(), - ripple::to_string(ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))) + ripple::to_string(ripple::makeMptID(2, getAccountIdWithString(kAccount))) ); }); } TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTokenType) { - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kMaxSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerinfo)); - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); auto const accountKk = ripple::keylet::account(account).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); auto const ownerDirKk = ripple::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1892,24 +1892,24 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTokenType) std::vector bbs; // put 1 mpt issuance auto const mptokenObject = - createMpTokenObject(kACCOUNT, ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))); + createMpTokenObject(kAccount, ripple::makeMptID(2, getAccountIdWithString(kAccount))); bbs.push_back(mptokenObject.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "type": "mptoken" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); auto const& accountObjects = output.result->as_object().at("account_objects").as_array(); ASSERT_EQ(accountObjects.size(), 1); diff --git a/tests/unit/rpc/handlers/AccountOffersTests.cpp b/tests/unit/rpc/handlers/AccountOffersTests.cpp index fb14582ba..16ef4717d 100644 --- a/tests/unit/rpc/handlers/AccountOffersTests.cpp +++ b/tests/unit/rpc/handlers/AccountOffersTests.cpp @@ -26,10 +26,10 @@ namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; } // namespace @@ -139,7 +139,7 @@ INSTANTIATE_TEST_CASE_P( RPCAccountOffersGroup1, AccountOfferParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountOfferParameterTest, InvalidParams) @@ -160,22 +160,22 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -185,26 +185,26 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaHash) TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaStringIndex) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)) + ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "{}" }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -214,26 +214,26 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaStringIndex) TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaIntIndex) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)) + ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -243,24 +243,24 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaIntIndex) TEST_F(RPCAccountOffersHandlerTest, AccountNotFound) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "actNotFound"); @@ -291,36 +291,36 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT, - kACCOUNT2 + kLedgerHash, + kAccount, + kAccount2 ); - constexpr auto kLEDGER_SEQ = 30; + constexpr auto kLedgerSeq = 30; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kLEDGER_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kLedgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex1}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; auto offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); offer.setFieldU32(ripple::sfExpiration, 123); bbs.push_back(offer.getSerializer().peekData()); @@ -328,17 +328,17 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(expectedOutput)); }); @@ -346,111 +346,111 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) TEST_F(RPCAccountOffersHandlerTest, Limit) { - constexpr auto kLEDGER_SEQ = 30; + constexpr auto kLedgerSeq = 30; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kLEDGER_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kLedgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) + createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kIndex1}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; for (auto i = 0; i < 20; i++) { auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); bbs.push_back(offer.getSerializer().peekData()); } ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": 10 }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->at("offers").as_array().size(), 10); - EXPECT_EQ(output.result->at("marker").as_string(), fmt::format("{},0", kINDEX1)); + EXPECT_EQ(output.result->at("marker").as_string(), fmt::format("{},0", kIndex1)); }); } TEST_F(RPCAccountOffersHandlerTest, Marker) { - constexpr auto kLEDGER_SEQ = 30; + constexpr auto kLedgerSeq = 30; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kLEDGER_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kLedgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const startPage = 2; auto const ownerDir = - createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kIndex1}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; auto const hintIndex = ripple::keylet::page(ownerDirKk, startPage).key; - ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLEDGER_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); std::vector bbs; for (auto i = 0; i < 20; i++) { auto const offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); bbs.push_back(offer.getSerializer().peekData()); } ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, - kINDEX1, + kAccount, + kIndex1, startPage ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->at("offers").as_array().size(), 19); EXPECT_FALSE(output.result->as_object().contains("marker")); @@ -459,38 +459,38 @@ TEST_F(RPCAccountOffersHandlerTest, Marker) TEST_F(RPCAccountOffersHandlerTest, MarkerNotExists) { - constexpr auto kLEDGER_SEQ = 30; + constexpr auto kLedgerSeq = 30; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kLEDGER_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kLedgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const startPage = 2; - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; auto const hintIndex = ripple::keylet::page(ownerDirKk, startPage).key; - ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLEDGER_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLedgerSeq, _)) .WillByDefault(Return(std::nullopt)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", - kACCOUNT, - kINDEX1, + kAccount, + kIndex1, startPage ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); @@ -500,117 +500,117 @@ TEST_F(RPCAccountOffersHandlerTest, MarkerNotExists) TEST_F(RPCAccountOffersHandlerTest, LimitLessThanMin) { - constexpr auto kLEDGER_SEQ = 30; + constexpr auto kLedgerSeq = 30; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kLEDGER_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kLedgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{AccountOffersHandler::kLimitMin + 1, ripple::uint256{kIndex1}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; auto offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); offer.setFieldU32(ripple::sfExpiration, 123); - bbs.reserve(AccountOffersHandler::kLIMIT_MIN + 1); - for (auto i = 0; i < AccountOffersHandler::kLIMIT_MIN + 1; i++) + bbs.reserve(AccountOffersHandler::kLimitMin + 1); + for (auto i = 0; i < AccountOffersHandler::kLimitMin + 1; i++) bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountOffersHandler::kLIMIT_MIN - 1 + kAccount, + AccountOffersHandler::kLimitMin - 1 ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("offers").as_array().size(), AccountOffersHandler::kLIMIT_MIN); + EXPECT_EQ(output.result->at("offers").as_array().size(), AccountOffersHandler::kLimitMin); }); } TEST_F(RPCAccountOffersHandlerTest, LimitMoreThanMax) { - constexpr auto kLEDGER_SEQ = 30; + constexpr auto kLedgerSeq = 30; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kLEDGER_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kLedgerSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{AccountOffersHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; auto offer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT2, + kAccount2, toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ); offer.setFieldU32(ripple::sfExpiration, 123); - bbs.reserve(AccountOffersHandler::kLIMIT_MAX + 1); - for (auto i = 0; i < AccountOffersHandler::kLIMIT_MAX + 1; i++) + bbs.reserve(AccountOffersHandler::kLimitMax + 1); + for (auto i = 0; i < AccountOffersHandler::kLimitMax + 1; i++) bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "limit": {} }})JSON", - kACCOUNT, - AccountOffersHandler::kLIMIT_MAX + 1 + kAccount, + AccountOffersHandler::kLimitMax + 1 ) ); auto const handler = AnyHandler{AccountOffersHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("offers").as_array().size(), AccountOffersHandler::kLIMIT_MAX); + EXPECT_EQ(output.result->at("offers").as_array().size(), AccountOffersHandler::kLimitMax); }); } diff --git a/tests/unit/rpc/handlers/AccountTxTests.cpp b/tests/unit/rpc/handlers/AccountTxTests.cpp index ed03794db..50636bf40 100644 --- a/tests/unit/rpc/handlers/AccountTxTests.cpp +++ b/tests/unit/rpc/handlers/AccountTxTests.cpp @@ -28,22 +28,22 @@ using namespace testing; namespace { -constexpr auto kMIN_SEQ = 10; -constexpr auto kMAX_SEQ = 30; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kNFT_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF"; -constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; -constexpr auto kNFT_ID3 = "15FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF"; -constexpr auto kINDEX = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kMinSeq = 10; +constexpr auto kMaxSeq = 30; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kNftId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF"; +constexpr auto kNftID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; +constexpr auto kNftID3 = "15FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF"; +constexpr auto kIndex = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; } // namespace struct RPCAccountTxHandlerTest : HandlerBaseTest { RPCAccountTxHandlerTest() { - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); } }; @@ -352,7 +352,7 @@ struct AccountTxParameterTest : public RPCAccountTxHandlerTest, "ledger_index_min": 11, "ledger_hash": "{}" }})JSON", - kLEDGER_HASH + kLedgerHash ), .expectedError = "invalidParams", .expectedErrorMessage = "containsLedgerSpecifierAndRange" @@ -366,7 +366,7 @@ struct AccountTxParameterTest : public RPCAccountTxHandlerTest, "ledger_index_min": 11, "ledger_hash": "{}" }})JSON", - kLEDGER_HASH + kLedgerHash ), .expectedError = std::nullopt, .expectedErrorMessage = std::nullopt, @@ -401,7 +401,7 @@ INSTANTIATE_TEST_CASE_P( RPCAccountTxGroup1, AccountTxParameterTest, ValuesIn(AccountTxParameterTest::generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountTxParameterTest, CheckParams) @@ -440,21 +440,21 @@ genTransactions(uint32_t seq1, uint32_t seq2) { auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = seq1; ripple::STObject const metaObj = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + createPaymentTransactionMetaObject(kAccount, kAccount2, 22, 23); trans1.metadata = metaObj.getSerializer().peekData(); trans1.date = 1; transactions.push_back(trans1); auto trans2 = TransactionAndMetadata(); - ripple::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj2 = createPaymentTransactionObject(kAccount, kAccount2, 1, 1, 32); trans2.transaction = obj.getSerializer().peekData(); trans2.ledgerSequence = seq2; ripple::STObject const metaObj2 = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + createPaymentTransactionMetaObject(kAccount, kAccount2, 22, 23); trans2.metadata = metaObj2.getSerializer().peekData(); trans2.date = 2; transactions.push_back(trans2); @@ -466,24 +466,24 @@ genNFTTransactions(uint32_t seq) { auto transactions = std::vector{}; - auto trans1 = createMintNftTxWithMetadata(kACCOUNT, 1, 50, 123, kNFT_ID); + auto trans1 = createMintNftTxWithMetadata(kAccount, 1, 50, 123, kNftId); trans1.ledgerSequence = seq; trans1.date = 1; transactions.push_back(trans1); - auto trans2 = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 50, kNFT_ID2, kINDEX); + auto trans2 = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 50, kNftID2, kIndex); trans2.ledgerSequence = seq; trans2.date = 2; transactions.push_back(trans2); auto trans3 = createCancelNftOffersTxWithMetadata( - kACCOUNT, 1, 50, std::vector{kNFT_ID2, kNFT_ID3} + kAccount, 1, 50, std::vector{kNftID2, kNftID3} ); trans3.ledgerSequence = seq; trans3.date = 3; transactions.push_back(trans3); - auto trans4 = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 50, kNFT_ID, 123, kNFT_ID2); + auto trans4 = createCreateNftOfferTxWithMetadata(kAccount, 1, 50, kNftId, 123, kNftID2); trans4.ledgerSequence = seq; trans4.date = 4; transactions.push_back(trans4); @@ -493,7 +493,7 @@ genNFTTransactions(uint32_t seq) TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -503,7 +503,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) testing::_, testing::_, true, - testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMinSeq, INT32_MAX})), testing::_ ) ); @@ -512,7 +512,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -520,16 +520,16 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) "ledger_index_max": {}, "forward": true }})JSON", - kACCOUNT, - kMIN_SEQ + 1, - kMAX_SEQ - 1 + kAccount, + kMinSeq + 1, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -541,7 +541,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -551,7 +551,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ); @@ -560,7 +560,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -568,16 +568,16 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) "ledger_index_max": {}, "forward": false }})JSON", - kACCOUNT, - kMIN_SEQ + 1, - kMAX_SEQ - 1 + kAccount, + kMinSeq + 1, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -589,7 +589,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -599,7 +599,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) testing::_, testing::_, true, - testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMinSeq - 1, INT32_MAX})), testing::_ ) ); @@ -608,7 +608,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -616,16 +616,16 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) "ledger_index_max": {}, "forward": true }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -637,7 +637,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -647,7 +647,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ); @@ -656,7 +656,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -664,16 +664,16 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) "ledger_index_max": {}, "forward": false }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -685,7 +685,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) TEST_F(RPCAccountTxHandlerTest, BinaryTrue) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -695,14 +695,14 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -710,16 +710,16 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue) "ledger_index_max": {}, "binary": true }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -747,7 +747,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue) TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; EXPECT_CALL( @@ -756,7 +756,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ) @@ -764,7 +764,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -772,16 +772,16 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) "ledger_index_max": {}, "binary": true }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -809,7 +809,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; EXPECT_CALL( @@ -828,7 +828,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -838,16 +838,16 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) "forward": false, "marker": {{"ledger": 10, "seq": 11}} }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ(output.result->at("limit").as_uint64(), 2); EXPECT_EQ( output.result->at("marker").as_object(), @@ -859,7 +859,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) TEST_F(RPCAccountTxHandlerTest, LimitIsCapped) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; EXPECT_CALL( @@ -870,7 +870,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitIsCapped) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -879,24 +879,24 @@ TEST_F(RPCAccountTxHandlerTest, LimitIsCapped) "limit": 100000, "forward": false }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("limit").as_uint64(), AccountTxHandler::kLIMIT_MAX); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); + EXPECT_EQ(output.result->at("limit").as_uint64(), AccountTxHandler::kLimitMax); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); }); } TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; EXPECT_CALL( @@ -907,7 +907,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -916,18 +916,18 @@ TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap) "limit": {}, "forward": false }})JSON", - kACCOUNT, + kAccount, -1, -1, - AccountTxHandler::kLIMIT_MAX - 1 + AccountTxHandler::kLimitMax - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("limit").as_uint64(), AccountTxHandler::kLIMIT_MAX - 1); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); + EXPECT_EQ(output.result->at("limit").as_uint64(), AccountTxHandler::kLimitMax - 1); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); }); } @@ -935,7 +935,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap) TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex) { // adjust the order for forward->false - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -945,32 +945,32 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq - 1); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq - 1, _)).WillOnce(Return(ledgerHeader)); ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, - kMAX_SEQ - 1 + kAccount, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMaxSeq - 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); @@ -979,21 +979,21 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex) TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillOnce(Return(std::nullopt)); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq - 1, _)).WillOnce(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, - kMAX_SEQ - 1 + kAccount, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -1003,21 +1003,21 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex) TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillOnce(Return(std::nullopt)); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq - 1, _)).WillOnce(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "{}" }})JSON", - kACCOUNT, - kMAX_SEQ - 1 + kAccount, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -1028,7 +1028,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex) TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash) { // adjust the order for forward->false - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -1038,35 +1038,35 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq - 1); EXPECT_CALL(*backend_, fetchLedgerByHash); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMaxSeq - 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); @@ -1076,7 +1076,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash) TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated) { // adjust the order for forward->false - auto const transactions = genTransactions(kMAX_SEQ, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMaxSeq, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -1086,32 +1086,32 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).WillOnce(Return(ledgerHeader)); ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index": "validated" }})JSON", - kACCOUNT + kAccount ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMaxSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); @@ -1120,7 +1120,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated) TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq) { - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -1130,7 +1130,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ); @@ -1139,7 +1139,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1147,16 +1147,16 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq) "ledger_index_max": {}, "forward": false }})JSON", - kACCOUNT, - kMIN_SEQ + 2, - kMAX_SEQ - 1 + kAccount, + kMinSeq + 2, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 2); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 2); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); @@ -1165,7 +1165,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq) TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) { - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -1175,7 +1175,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 2, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 2, INT32_MAX})), testing::_ ) ); @@ -1184,7 +1184,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1192,16 +1192,16 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) "ledger_index_max": {}, "forward": false }})JSON", - kACCOUNT, - kMIN_SEQ + 1, - kMAX_SEQ - 2 + kAccount, + kMinSeq + 1, + kMaxSeq - 2 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 2); + EXPECT_EQ(output.result->at("account").as_string(), kAccount); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 2); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_EQ( @@ -1389,7 +1389,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1) } })JSON"; - auto const transactions = genNFTTransactions(kMIN_SEQ + 1); + auto const transactions = genNFTTransactions(kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -1408,7 +1408,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1417,12 +1417,12 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1) "forward": false, "marker": {{"ledger": 10, "seq": 11}} }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 1u}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 1u}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(out)); }); @@ -1613,7 +1613,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2) } })JSON"; - auto const transactions = genNFTTransactions(kMIN_SEQ + 1); + auto const transactions = genNFTTransactions(kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); @@ -1630,14 +1630,14 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2) ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 11); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 11); EXPECT_CALL(*backend_, fetchLedgerBySequence) .Times(transactions.size()) .WillRepeatedly(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1646,12 +1646,12 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2) "forward": false, "marker": {{"ledger": 10, "seq": 11}} }})JSON", - kACCOUNT, + kAccount, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(out)); }); @@ -1710,14 +1710,14 @@ TEST_F(RPCAccountTxHandlerTest, MPTTxs_API_v2) ], "validated": true }})JSON", - kACCOUNT, - kACCOUNT, - kLEDGER_HASH, - kACCOUNT + kAccount, + kAccount, + kLedgerHash, + kAccount ); - auto mptTx = createMPTIssuanceCreateTxWithMetadata(kACCOUNT, 50, 1); - mptTx.ledgerSequence = kMIN_SEQ + 1; + auto mptTx = createMPTIssuanceCreateTxWithMetadata(kAccount, 50, 1); + mptTx.ledgerSequence = kMinSeq + 1; mptTx.date = 1; auto transactions = std::vector{std::move(mptTx)}; @@ -1726,24 +1726,24 @@ TEST_F(RPCAccountTxHandlerTest, MPTTxs_API_v2) EXPECT_CALL(*backend_, fetchAccountTransactions).WillOnce(Return(transCursor)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMIN_SEQ + 1); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMIN_SEQ + 1, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMinSeq + 1); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMinSeq + 1, _)).WillOnce(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "ledger_index_min": {}, "ledger_index_max": {} }})JSON", - kACCOUNT, - kMIN_SEQ, - kMAX_SEQ + kAccount, + kMinSeq, + kMaxSeq ) ); - auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u}); + auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); EXPECT_EQ(*output.result, json::parse(out)); }); @@ -2236,25 +2236,25 @@ INSTANTIATE_TEST_CASE_P( RPCAccountTxTransactionTypeTest, AccountTxTransactionTypeTest, ValuesIn(generateTransactionTypeTestValues()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(AccountTxTransactionTypeTest, SpecificTransactionType) { - auto const transactions = genTransactions(kMAX_SEQ, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMaxSeq, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor)); EXPECT_CALL( *backend_, fetchAccountTransactions( - _, _, false, Optional(Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), _ + _, _, false, Optional(Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), _ ) ); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader)); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).Times(Between(1, 2)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); + ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).WillByDefault(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).Times(Between(1, 2)); ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); diff --git a/tests/unit/rpc/handlers/AllHandlerTests.cpp b/tests/unit/rpc/handlers/AllHandlerTests.cpp index ed3b2d696..0e808c19c 100644 --- a/tests/unit/rpc/handlers/AllHandlerTests.cpp +++ b/tests/unit/rpc/handlers/AllHandlerTests.cpp @@ -57,13 +57,12 @@ using ::testing::Types; using namespace rpc; using TestServerInfoHandler = BaseServerInfoHandler; -static constexpr auto kINDEX1 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; -static constexpr auto kAMM_ACCOUNT = "rLcS7XL6nxRAi7JcbJcn1Na179oF3vdfbh"; -static constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -static constexpr auto kNFT_ID = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; -static constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -static constexpr auto kVAULT_ID = - "61B03A6F8CEBD3AF9D8F696C3D0A9A9F0493B34BF6B5D93CF0BC009E6BA75303"; +static constexpr auto kIndex1 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +static constexpr auto kAmmAccount = "rLcS7XL6nxRAi7JcbJcn1Na179oF3vdfbh"; +static constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +static constexpr auto kNftId = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; +static constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +static constexpr auto kVaultId = "61B03A6F8CEBD3AF9D8F696C3D0A9A9F0493B34BF6B5D93CF0BC009E6BA75303"; using AnyHandlerType = Types< AccountChannelsHandler, @@ -169,7 +168,7 @@ AccountInfoHandler::Input createInput() { AccountInfoHandler::Input input{}; - input.account = kACCOUNT; + input.account = kAccount; input.ident = "asdf"; return input; } @@ -179,7 +178,7 @@ AccountTxHandler::Input createInput() { AccountTxHandler::Input input{}; - input.account = kACCOUNT; + input.account = kAccount; return input; } @@ -188,7 +187,7 @@ AMMInfoHandler::Input createInput() { AMMInfoHandler::Input input{}; - input.ammAccount = getAccountIdWithString(kAMM_ACCOUNT); + input.ammAccount = getAccountIdWithString(kAmmAccount); return input; } @@ -198,9 +197,9 @@ createInput() { BookOffersHandler::Input input{}; input.paysCurrency = ripple::xrpCurrency(); - input.getsCurrency = ripple::Currency(kCURRENCY); + input.getsCurrency = ripple::Currency(kCurrency); input.paysID = ripple::xrpAccount(); - input.getsID = getAccountIdWithString(kACCOUNT); + input.getsID = getAccountIdWithString(kAccount); return input; } @@ -210,7 +209,7 @@ LedgerEntryHandler::Input createInput() { LedgerEntryHandler::Input input{}; - input.index = kINDEX1; + input.index = kIndex1; return input; } @@ -219,7 +218,7 @@ NFTBuyOffersHandler::Input createInput() { NFTBuyOffersHandler::Input input{}; - input.nftID = kNFT_ID; + input.nftID = kNftId; return input; } @@ -228,7 +227,7 @@ NFTInfoHandler::Input createInput() { NFTInfoHandler::Input input{}; - input.nftID = kNFT_ID; + input.nftID = kNftId; return input; } @@ -237,7 +236,7 @@ NFTSellOffersHandler::Input createInput() { NFTSellOffersHandler::Input input{}; - input.nftID = kNFT_ID; + input.nftID = kNftId; return input; } @@ -248,7 +247,7 @@ createInput() SubscribeHandler::Input input{}; input.books = std::vector{SubscribeHandler::OrderBook{ - .book = ripple::Book{}, .taker = kACCOUNT, .snapshot = true, .both = true + .book = ripple::Book{}, .taker = kAccount, .snapshot = true, .both = true }}; return input; } @@ -258,7 +257,7 @@ VaultInfoHandler::Input createInput() { VaultInfoHandler::Input input{}; - input.vaultID = kVAULT_ID; + input.vaultID = kVaultId; return input; } diff --git a/tests/unit/rpc/handlers/BookChangesTests.cpp b/tests/unit/rpc/handlers/BookChangesTests.cpp index 7c8d42cb0..56521bbc2 100644 --- a/tests/unit/rpc/handlers/BookChangesTests.cpp +++ b/tests/unit/rpc/handlers/BookChangesTests.cpp @@ -26,21 +26,21 @@ using namespace testing; namespace { -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kDOMAIN = "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134E5"; -constexpr auto kMAX_SEQ = 30; -constexpr auto kMIN_SEQ = 10; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kAccount1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kDomain = "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134E5"; +constexpr auto kMaxSeq = 30; +constexpr auto kMinSeq = 10; } // namespace struct RPCBookChangesHandlerTest : HandlerBaseTest { RPCBookChangesHandlerTest() { - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); } }; @@ -84,7 +84,7 @@ INSTANTIATE_TEST_CASE_P( RPCBookChangesGroup1, BookChangesParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(BookChangesParameterTest, InvalidParams) @@ -105,13 +105,13 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)) + ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse(R"JSON({"ledger_index": 30})JSON"); + static auto const kInput = json::parse(R"JSON({"ledger_index": 30})JSON"); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -123,12 +123,12 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse(R"JSON({"ledger_index": "30"})JSON"); + static auto const kInput = json::parse(R"JSON({"ledger_index": "30"})JSON"); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -139,20 +139,20 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}" }})JSON", - kLEDGER_HASH + kLedgerHash ) ); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -162,7 +162,7 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaHash) TEST_F(RPCBookChangesHandlerTest, NormalPath) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "type": "bookChanges", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", @@ -183,33 +183,32 @@ TEST_F(RPCBookChangesHandlerTest, NormalPath) ] })JSON"; - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kMAX_SEQ))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kMaxSeq))); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 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(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + createMetaDataForBookChange(kCurrency, kIssuer, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kMAX_SEQ, _)) - .WillOnce(Return(transactions)); + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kMaxSeq, _)).WillOnce(Return(transactions)); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process(json::parse("{}"), Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCBookChangesHandlerTest, NormalPathWithDomain) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "type": "bookChanges", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", @@ -231,26 +230,25 @@ TEST_F(RPCBookChangesHandlerTest, NormalPathWithDomain) ] })JSON"; - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kMAX_SEQ))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kMaxSeq))); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 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(kCURRENCY, kISSUER, 22, 1, 3, 3, 1, kDOMAIN); + createMetaDataForBookChange(kCurrency, kIssuer, 22, 1, 3, 3, 1, kDomain); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kMAX_SEQ, _)) - .WillOnce(Return(transactions)); + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kMaxSeq, _)).WillOnce(Return(transactions)); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process(json::parse("{}"), Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } diff --git a/tests/unit/rpc/handlers/BookOffersTests.cpp b/tests/unit/rpc/handlers/BookOffersTests.cpp index 7cd97bd73..e5795991b 100644 --- a/tests/unit/rpc/handlers/BookOffersTests.cpp +++ b/tests/unit/rpc/handlers/BookOffersTests.cpp @@ -34,22 +34,22 @@ namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kPAYS20_USD_GETS10_XRP_BOOK_DIR = +constexpr auto kPayS20UsdGetS10XrpBookDir = "43B83ADC452B85FCBADA6CAEAC5181C255A213630D58FFD455071AFD498D0000"; -constexpr auto kPAYS20_XRP_GETS10_USD_BOOK_DIR = +constexpr auto kPayS20XrpGetS10UsdBookDir = "7B1767D41DBCE79D9585CF9D0262A5FEC45E5206FF524F8B55071AFD498D0000"; -constexpr auto kTRANSFER_RATE_X2 = 2000000000; +constexpr auto kTransferRateX2 = 2000000000; -constexpr auto kDOMAIN = "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134E5"; +constexpr auto kDomain = "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134E5"; struct ParameterTestBundle { std::string testName; @@ -491,7 +491,7 @@ INSTANTIATE_TEST_SUITE_P( RPCBookOffersHandler, RPCBookOffersParameterTest, testing::ValuesIn(generateParameterBookOffersTestBundles()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct BookOffersNormalTestBundle { @@ -515,7 +515,7 @@ TEST_P(RPCBookOffersNormalPathTest, CheckOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, seq); ON_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::fixFrozenLPTokenTransfer, _)) @@ -556,56 +556,56 @@ TEST_P(RPCBookOffersNormalPathTest, CheckOutput) static auto generateNormalPathBookOffersTestBundles() { - auto const account = getAccountIdWithString(kACCOUNT); - auto const account2 = getAccountIdWithString(kACCOUNT2); + auto const account = getAccountIdWithString(kAccount); + auto const account2 = getAccountIdWithString(kAccount2); auto const frozenTrustLine = createRippleStateLedgerObject( - "USD", kACCOUNT, -8, kACCOUNT2, 1000, kACCOUNT, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kAccount, -8, kAccount2, 1000, kAccount, 2000, kIndex1, 2, ripple::lsfLowFreeze ); auto const gets10USDPays20XRPOffer = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT, + kAccount, toBase58(ripple::xrpAccount()), - kPAYS20_XRP_GETS10_USD_BOOK_DIR + kPayS20XrpGetS10UsdBookDir ); auto const gets10USDPays20XRPOwnerOffer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT, + kAccount, toBase58(ripple::xrpAccount()), - kPAYS20_XRP_GETS10_USD_BOOK_DIR + kPayS20XrpGetS10UsdBookDir ); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::xrpCurrency()), ripple::to_string(ripple::to_currency("USD")), toBase58(ripple::xrpAccount()), - kACCOUNT, - kPAYS20_USD_GETS10_XRP_BOOK_DIR + kAccount, + kPayS20UsdGetS10XrpBookDir ); auto const gets10XRPPays20USDOfferWithDomain = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::xrpCurrency()), ripple::to_string(ripple::to_currency("USD")), toBase58(ripple::xrpAccount()), - kACCOUNT, - kPAYS20_USD_GETS10_XRP_BOOK_DIR, - kDOMAIN + kAccount, + kPayS20UsdGetS10XrpBookDir, + kDomain ); auto const getsXRPPaysUSDBook = getBookBase( @@ -624,7 +624,7 @@ generateNormalPathBookOffersTestBundles() account, ripple::xrpCurrency(), ripple::xrpAccount(), - kDOMAIN + kDomain ) .value() ); @@ -649,7 +649,7 @@ generateNormalPathBookOffersTestBundles() "issuer": "{}" }} }})JSON", - kACCOUNT + kAccount ); auto const getsXRPPaysUSDInputJsonWithDomain = fmt::format( @@ -663,8 +663,8 @@ generateNormalPathBookOffersTestBundles() }}, "domain": "{}" }})JSON", - kACCOUNT, - kDOMAIN + kAccount, + kDomain ); auto const paysXRPGetsUSDInputJson = fmt::format( @@ -677,17 +677,17 @@ generateNormalPathBookOffersTestBundles() "issuer": "{}" }} }})JSON", - kACCOUNT + kAccount ); auto const feeLedgerObject = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustline30Balance = createRippleStateLedgerObject( - "USD", kACCOUNT, -30, kACCOUNT2, 1000, kACCOUNT, 2000, kINDEX1, 2, 0 + "USD", kAccount, -30, kAccount2, 1000, kAccount, 2000, kIndex1, 2, 0 ); auto const trustline8Balance = createRippleStateLedgerObject( - "USD", kACCOUNT, -8, kACCOUNT2, 1000, kACCOUNT, 2000, kINDEX1, 2, 0 + "USD", kAccount, -8, kAccount2, 1000, kAccount, 2000, kIndex1, 2, 0 ); return std::vector{ @@ -697,25 +697,24 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + {getsXRPPaysUSDBook, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // pays issuer account object {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData()}, // owner account object {ripple::keylet::account(account2).key, - createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData()}, // fee settings: base ->3 inc->2, account2 has 2 objects ,total @@ -752,8 +751,8 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, + kLedgerHash, + kAccount2, 193, 2 ) @@ -764,25 +763,24 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + {getsXRPPaysUSDBook, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // pays issuer account object {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData()}, // owner account object, hold {ripple::keylet::account(account2).key, - createAccountRootObject(kACCOUNT2, 0, 2, 5 + 7, 2, kINDEX1, 2) + createAccountRootObject(kAccount2, 0, 2, 5 + 7, 2, kIndex1, 2) .getSerializer() .peekData()}, // fee settings: base ->3 inc->2, account2 has 2 objects @@ -825,8 +823,8 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, + kLedgerHash, + kAccount2, 5, 2 ) @@ -837,21 +835,20 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + {getsXRPPaysUSDBook, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // pays issuer account object {ripple::keylet::account(account).key, createAccountRootObject( - kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2 + kAccount, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2 ) .getSerializer() .peekData()} @@ -891,8 +888,8 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, + kLedgerHash, + kAccount2, 0, 2 ) @@ -903,22 +900,20 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsXRPPaysUSDBookWithDomain, - ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + {getsXRPPaysUSDBookWithDomain, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // pays issuer account object {ripple::keylet::account(account).key, createAccountRootObject( - kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2 + kAccount, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2 ) .getSerializer() .peekData()} @@ -959,8 +954,8 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, + kLedgerHash, + kAccount2, 0, 2 ) @@ -971,21 +966,20 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object {ripple::keylet::account(account).key, createAccountRootObject( - kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 + kAccount, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 ) .getSerializer() .peekData()} @@ -1025,9 +1019,9 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 0, 2 ) @@ -1038,20 +1032,19 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, rate is 1/2 {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2, kTransferRateX2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 8 USD @@ -1093,9 +1086,9 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 8, 2 ), @@ -1107,22 +1100,21 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 + {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 ) .getSerializer() .peekData()}, // gets issuer account object {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2, kTransferRateX2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 30 USD @@ -1190,13 +1182,13 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 30, 2, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 2 ), .amendmentIsEnabledCalls = 1, @@ -1207,20 +1199,19 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, rate is 1/2 {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2, kTransferRateX2) .getSerializer() .peekData()}, }, @@ -1253,9 +1244,9 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount, + kPayS20XrpGetS10UsdBookDir, 10, 2 ) @@ -1266,20 +1257,19 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, rate is 1/2 {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2, kTransferRateX2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 8 USD @@ -1321,9 +1311,9 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 0, 2 ), @@ -1334,28 +1324,20 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, is deep frozen so unfunded {ripple::keylet::account(account).key, createAccountRootObject( - kACCOUNT, - ripple::lsfLowDeepFreeze, - 2, - 200, - 2, - kINDEX1, - 2, - kTRANSFER_RATE_X2 + kAccount, ripple::lsfLowDeepFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 ) .getSerializer() .peekData()}, @@ -1395,9 +1377,9 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 0, 2 ) @@ -1408,28 +1390,20 @@ generateNormalPathBookOffersTestBundles() // prepare offer dir index .mockedSuccessors = std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, is deep frozen so unfunded {ripple::keylet::account(account).key, createAccountRootObject( - kACCOUNT, - ripple::lsfLowDeepFreeze, - 2, - 200, - 2, - kINDEX1, - 2, - kTRANSFER_RATE_X2 + kAccount, ripple::lsfLowDeepFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 ) .getSerializer() .peekData()}, @@ -1472,9 +1446,9 @@ generateNormalPathBookOffersTestBundles() }} ] }})JSON", - kLEDGER_HASH, - kACCOUNT2, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, + kLedgerHash, + kAccount2, + kPayS20XrpGetS10UsdBookDir, 0, 2 ) @@ -1486,7 +1460,7 @@ INSTANTIATE_TEST_SUITE_P( RPCBookOffersHandler, RPCBookOffersNormalPathTest, testing::ValuesIn(generateNormalPathBookOffersTestBundles()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); // ledger not exist @@ -1497,7 +1471,7 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaIntSequence) ON_CALL(*backend_, fetchLedgerBySequence(30, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "ledger_index": 30, @@ -1509,12 +1483,12 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaIntSequence) "issuer": "{}" }} }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield}); + auto const output = handler.process(kInput, Context{.yield = yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -1529,7 +1503,7 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaSequence) ON_CALL(*backend_, fetchLedgerBySequence(30, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "ledger_index": "30", @@ -1541,12 +1515,12 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaSequence) "issuer": "{}" }} }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield}); + auto const output = handler.process(kInput, Context{.yield = yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -1558,10 +1532,10 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1573,13 +1547,13 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaHash) "issuer": "{}" }} }})JSON", - kLEDGER_HASH, - kACCOUNT + kLedgerHash, + kAccount ) ); auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield}); + auto const output = handler.process(kInput, Context{.yield = yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -1593,10 +1567,10 @@ TEST_F(RPCBookOffersHandlerTest, Limit) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, seq); ON_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillByDefault(Return(ledgerHeader)); - auto const issuer = getAccountIdWithString(kACCOUNT); + auto const issuer = getAccountIdWithString(kAccount); // return valid book dir EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); @@ -1611,23 +1585,21 @@ TEST_F(RPCBookOffersHandlerTest, Limit) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); + auto const indexes = std::vector(10, ripple::uint256{kIndex2}); - ON_CALL( - *backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _) - ) + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, seq, _)) .WillByDefault( - Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) + Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, seq, _) ) .WillByDefault(Return( - createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, seq, _)) @@ -1635,27 +1607,27 @@ TEST_F(RPCBookOffersHandlerTest, Limit) ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuer).key, seq, _)) .WillByDefault( - Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) + Return(createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2, kTransferRateX2) .getSerializer() .peekData()) ); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::xrpCurrency()), ripple::to_string(ripple::to_currency("USD")), toBase58(ripple::xrpAccount()), - kACCOUNT, - kPAYS20_USD_GETS10_XRP_BOOK_DIR + kAccount, + kPayS20UsdGetS10XrpBookDir ); std::vector const bbs(10, gets10XRPPays20USDOffer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "taker_gets": {{ @@ -1667,12 +1639,12 @@ TEST_F(RPCBookOffersHandlerTest, Limit) }}, "limit": 5 }})JSON", - kACCOUNT + kAccount ) ); auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield}); + auto const output = handler.process(kInput, Context{.yield = yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result.value().as_object().at("offers").as_array().size(), 5); }); @@ -1684,10 +1656,10 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, seq); ON_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillByDefault(Return(ledgerHeader)); - auto const issuer = getAccountIdWithString(kACCOUNT); + auto const issuer = getAccountIdWithString(kAccount); // return valid book dir EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); @@ -1702,24 +1674,22 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); auto const indexes = - std::vector(BookOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX2}); + std::vector(BookOffersHandler::kLimitMax + 1, ripple::uint256{kIndex2}); - ON_CALL( - *backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _) - ) + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, seq, _)) .WillByDefault( - Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) + Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, seq, _) ) .WillByDefault(Return( - createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, seq, _)) @@ -1727,29 +1697,29 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuer).key, seq, _)) .WillByDefault( - Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) + Return(createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2, kTransferRateX2) .getSerializer() .peekData()) ); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::xrpCurrency()), ripple::to_string(ripple::to_currency("USD")), toBase58(ripple::xrpAccount()), - kACCOUNT, - kPAYS20_USD_GETS10_XRP_BOOK_DIR + kAccount, + kPayS20UsdGetS10XrpBookDir ); std::vector const bbs( - BookOffersHandler::kLIMIT_MAX + 1, gets10XRPPays20USDOffer.getSerializer().peekData() + BookOffersHandler::kLimitMax + 1, gets10XRPPays20USDOffer.getSerializer().peekData() ); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "taker_gets": {{ @@ -1761,17 +1731,17 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) }}, "limit": {} }})JSON", - kACCOUNT, - BookOffersHandler::kLIMIT_MAX + 1 + kAccount, + BookOffersHandler::kLimitMax + 1 ) ); auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(kINPUT, Context{.yield = yield}); + auto const output = handler.process(kInput, Context{.yield = yield}); ASSERT_TRUE(output); EXPECT_EQ( output.result.value().as_object().at("offers").as_array().size(), - BookOffersHandler::kLIMIT_MAX + BookOffersHandler::kLimitMax ); }); } diff --git a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp index 9a90974fc..7a08e7b38 100644 --- a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp +++ b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp @@ -31,19 +31,19 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kCREDENTIAL_ID = "c7a14f6b9d5d4a9cb9c223a61b8e5c7df58e8b7ad1c6b4f8e7a321fa4e5b4c9d"; -constexpr std::string_view kCREDENTIAL_TYPE = "credType"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kIndex1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kCredentialId = "c7a14f6b9d5d4a9cb9c223a61b8e5c7df58e8b7ad1c6b4f8e7a321fa4e5b4c9d"; +constexpr std::string_view kCredentialType = "credType"; } // namespace TEST(CreateAuthCredentialsTest, UniqueCredentials) { ripple::STArray credentials; - auto const cred1 = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const cred2 = createCredentialObject(kACCOUNT2, kACCOUNT, kCREDENTIAL_TYPE); + auto const cred1 = createCredentialObject(kAccount, kAccount2, kCredentialType); + auto const cred2 = createCredentialObject(kAccount2, kAccount, kCredentialType); credentials.push_back(cred1); credentials.push_back(cred2); @@ -71,8 +71,8 @@ TEST(ParseAuthorizeCredentialsTest, ValidCredentialsArray) { boost::json::array credentials; boost::json::object credential1; - credential1[JS(issuer)] = kACCOUNT; - credential1[JS(credential_type)] = ripple::strHex(kCREDENTIAL_TYPE); + credential1[JS(issuer)] = kAccount; + credential1[JS(credential_type)] = ripple::strHex(kCredentialType); credentials.push_back(credential1); ripple::STArray const parsedCredentials = credentials::parseAuthorizeCredentials(credentials); @@ -101,12 +101,12 @@ class CredentialHelperTest : public util::prometheus::WithPrometheus, TEST_F(CredentialHelperTest, GetInvalidCredentialArray) { - boost::json::array credentialsArray = {kCREDENTIAL_ID}; - auto const info = createLedgerHeader(kINDEX1, 30); + boost::json::array credentialsArray = {kCredentialId}; + auto const info = createLedgerHeader(kIndex1, 30); util::spawn(ctx_, [&](boost::asio::yield_context yield) { auto const ret = credentials::fetchCredentialArray( - credentialsArray, getAccountIdWithString(kACCOUNT), *backend_, info, yield + credentialsArray, getAccountIdWithString(kAccount), *backend_, info, yield ); ASSERT_FALSE(ret.has_value()); auto const status = ret.error(); @@ -120,28 +120,28 @@ TEST_F(CredentialHelperTest, GetValidCredentialArray) { backend_->setRange(10, 30); - auto ledgerHeader = createLedgerHeader(kINDEX1, 30); + auto ledgerHeader = createLedgerHeader(kIndex1, 30); auto const credLedgerObject = - createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, true); + createCredentialObject(kAccount, kAccount2, kCredentialType, true); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)) .WillByDefault(Return(credLedgerObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - boost::json::array credentialsArray = {kCREDENTIAL_ID}; + boost::json::array credentialsArray = {kCredentialId}; ripple::STArray expectedAuthCreds; ripple::STObject credential(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, getAccountIdWithString(kACCOUNT2)); + credential.setAccountID(ripple::sfIssuer, getAccountIdWithString(kAccount2)); credential.setFieldVL( ripple::sfCredentialType, - ripple::Blob{std::begin(kCREDENTIAL_TYPE), std::end(kCREDENTIAL_TYPE)} + ripple::Blob{std::begin(kCredentialType), std::end(kCredentialType)} ); expectedAuthCreds.push_back(std::move(credential)); util::spawn(ctx_, [&](boost::asio::yield_context yield) { auto const result = credentials::fetchCredentialArray( - credentialsArray, getAccountIdWithString(kACCOUNT), *backend_, ledgerHeader, yield + credentialsArray, getAccountIdWithString(kAccount), *backend_, ledgerHeader, yield ); ASSERT_TRUE(result.has_value()); EXPECT_EQ(result.value(), expectedAuthCreds); diff --git a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp index 5fe9909bf..e07b4f948 100644 --- a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp +++ b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp @@ -28,17 +28,16 @@ namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B1"; -constexpr auto kCREDENTIAL_HASH = - "F245428267E6177AEEFDD4FEA3533285712A4B1091CF82A7EA7BC39A62C3FB1A"; -constexpr std::string_view kCREDENTIAL_TYPE = "credType"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B1"; +constexpr auto kCredentialHash = "F245428267E6177AEEFDD4FEA3533285712A4B1091CF82A7EA7BC39A62C3FB1A"; +constexpr std::string_view kCredentialType = "credType"; -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; } // namespace @@ -50,7 +49,7 @@ using namespace testing; struct RPCDepositAuthorizedTest : HandlerBaseTest { RPCDepositAuthorizedTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } }; @@ -196,7 +195,7 @@ INSTANTIATE_TEST_CASE_P( RPCDepositAuthorizedGroup, DepositAuthorizedParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(DepositAuthorizedParameterTest, InvalidParams) @@ -218,7 +217,7 @@ TEST_P(DepositAuthorizedParameterTest, InvalidParams) TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{DepositAuthorizedHandler{backend_}}; @@ -229,9 +228,9 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaIntSequence) "destination_account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, - kACCOUNT2, - kRANGE_MAX + kAccount, + kAccount2, + kRangeMax ) ); @@ -247,7 +246,7 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaIntSequence) TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{DepositAuthorizedHandler{backend_}}; @@ -258,9 +257,9 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) "destination_account": "{}", "ledger_index": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kRANGE_MAX + kAccount, + kAccount2, + kRangeMax ) ); @@ -276,7 +275,7 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -288,9 +287,9 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaHash) "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -305,9 +304,9 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaHash) TEST_F(RPCDepositAuthorizedTest, SourceAccountDoesNotExist) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -321,9 +320,9 @@ TEST_F(RPCDepositAuthorizedTest, SourceAccountDoesNotExist) "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -341,18 +340,18 @@ TEST_F(RPCDepositAuthorizedTest, SourceAccountDoesNotExist) TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(std::optional{})); @@ -365,9 +364,9 @@ TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -385,7 +384,7 @@ TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -395,13 +394,13 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) "destination_account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const accountRoot = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(accountRoot.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -413,9 +412,9 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT, - kLEDGER_HASH + kAccount, + kAccount, + kLedgerHash ) ); @@ -424,13 +423,13 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -440,23 +439,23 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) "destination_account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun" })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX2, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); + auto const account2Root = createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex2, 2); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -468,9 +467,9 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -479,13 +478,13 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFalse) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -495,25 +494,25 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals "destination_account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun" })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::nullopt)); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); @@ -525,9 +524,9 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -536,13 +535,13 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -552,26 +551,26 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue "destination_account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun" })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); @@ -583,9 +582,9 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue "destination_account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -594,13 +593,13 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) { - static auto const kEXPECTED_OUT = fmt::format( + static auto const kExpectedOut = fmt::format( R"JSON({{ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -610,22 +609,22 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) "destination_account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun", "credentials": ["{}"] }})JSON", - kCREDENTIAL_HASH // CREDENTIALHASH should match credentialIndex + kCredentialHash // CREDENTIALHASH should match credentialIndex ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); - auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); + auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType); auto const credentialIndex = ripple::keylet::credential( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -633,12 +632,12 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -653,9 +652,9 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) "ledger_hash": "{}", "credentials": ["{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH, + kAccount, + kAccount2, + kLedgerHash, ripple::strHex(credentialIndex) ) ); @@ -665,25 +664,25 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); - auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, false); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); + auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType, false); auto const credentialIndex = ripple::keylet::credential( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -691,12 +690,12 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -712,9 +711,9 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) "ledger_hash": "{}", "credentials": ["{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH, + kAccount, + kAccount2, + kLedgerHash, ripple::strHex(credentialIndex) ) ); @@ -732,26 +731,26 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 100); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 100); // set parent close time to 500 seconds ledgerHeader.parentCloseTime = ripple::NetClock::time_point{std::chrono::seconds{500}}; - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); // credential expire time is 23 seconds, so credential will fail auto const expiredCredential = - createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, true, 23); + createCredentialObject(kAccount, kAccount2, kCredentialType, true, 23); auto const credentialIndex = ripple::keylet::credential( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -759,12 +758,12 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -780,9 +779,9 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) "ledger_hash": "{}", "credentials": ["{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH, + kAccount, + kAccount2, + kLedgerHash, ripple::strHex(credentialIndex) ) ); @@ -800,19 +799,19 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); - auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); + auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType); auto const credentialIndex = ripple::keylet::credential( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -820,12 +819,12 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -841,9 +840,9 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) "ledger_hash": "{}", "credentials": ["{}", "{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH, + kAccount, + kAccount2, + kLedgerHash, ripple::strHex(credentialIndex), ripple::strHex(credentialIndex) ) @@ -862,25 +861,25 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) TEST_F(RPCDepositAuthorizedTest, NoElementsInCredentialsReturnsFalse) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); @@ -894,9 +893,9 @@ TEST_F(RPCDepositAuthorizedTest, NoElementsInCredentialsReturnsFalse) "ledger_hash": "{}", "credentials": [] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH + kAccount, + kAccount2, + kLedgerHash ) ); @@ -913,19 +912,19 @@ TEST_F(RPCDepositAuthorizedTest, NoElementsInCredentialsReturnsFalse) TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); - auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); + auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType); auto const credentialIndex = ripple::keylet::credential( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -933,12 +932,12 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -956,9 +955,9 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) "ledger_hash": "{}", "credentials": [{}] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH, + kAccount, + kAccount2, + kLedgerHash, fmt::join( credentials | std::views::transform([](std::string const& cred) { return fmt::format("\"{}\"", cred); @@ -981,21 +980,21 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFalse) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); + auto const account1Root = createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kAccount2, ripple::lsfDepositAuth, 2, 200, 2, kIndex2, 2); // reverse the subject and issuer account. Now subject is Account2 - auto const credential = createCredentialObject(kACCOUNT2, kACCOUNT, kCREDENTIAL_TYPE); + auto const credential = createCredentialObject(kAccount2, kAccount, kCredentialType); auto const credentialIndex = ripple::keylet::credential( - getAccountIdWithString(kACCOUNT2), - getAccountIdWithString(kACCOUNT), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + getAccountIdWithString(kAccount2), + getAccountIdWithString(kAccount), + ripple::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -1003,12 +1002,12 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _) + doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -1023,9 +1022,9 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals "ledger_hash": "{}", "credentials": ["{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kLEDGER_HASH, + kAccount, + kAccount2, + kLedgerHash, ripple::strHex(credentialIndex) ) ); diff --git a/tests/unit/rpc/handlers/FeatureTests.cpp b/tests/unit/rpc/handlers/FeatureTests.cpp index 3483da0cd..387523d3a 100644 --- a/tests/unit/rpc/handlers/FeatureTests.cpp +++ b/tests/unit/rpc/handlers/FeatureTests.cpp @@ -24,18 +24,18 @@ using namespace data; namespace { -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; -constexpr auto kSEQ = 30; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kAPI_VERSION = 2; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; +constexpr auto kSeq = 30; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kApiVersion = 2; } // namespace struct RPCFeatureHandlerTest : HandlerBaseTest { RPCFeatureHandlerTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } protected: @@ -146,7 +146,7 @@ INSTANTIATE_TEST_CASE_P( RPCFeatureGroup1, RPCFeatureHandlerParamTest, testing::ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(RPCFeatureHandlerParamTest, InvalidParams) @@ -156,7 +156,7 @@ TEST_P(RPCFeatureHandlerParamTest, InvalidParams) auto const handler = AnyHandler{FeatureHandler{backend_, mockAmendmentCenterPtr_}}; auto const req = boost::json::parse(testBundle.testJson); auto const output = - handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -167,7 +167,7 @@ TEST_P(RPCFeatureHandlerParamTest, InvalidParams) TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaIntSequence) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -177,7 +177,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaIntSequence) R"JSON({{ "ledger_index": {} }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -190,7 +190,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaIntSequence) TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaStringSequence) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -200,7 +200,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaStringSequence) R"JSON({{ "ledger_index": "{}" }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -213,7 +213,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -223,7 +223,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaHash) R"JSON({{ "ledger_hash": "{}" }})JSON", - kLEDGER_HASH + kLedgerHash ) ); auto const output = handler.process(req, Context{yield}); @@ -273,10 +273,10 @@ TEST_F(RPCFeatureHandlerTest, SuccessPathViaNameWithSingleSupportedAndEnabledRes auto const enabled = std::vector{true}; EXPECT_CALL(*mockAmendmentCenterPtr_, getAll).WillOnce(testing::ReturnRef(all)); - EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSEQ)) + EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSeq)) .WillOnce(testing::Return(enabled)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const expectedOutput = fmt::format( @@ -290,8 +290,8 @@ TEST_F(RPCFeatureHandlerTest, SuccessPathViaNameWithSingleSupportedAndEnabledRes "ledger_index": {}, "validated": true }})JSON", - kLEDGER_HASH, - kSEQ + kLedgerHash, + kSeq ); runSpawn([this, &expectedOutput](auto yield) { @@ -325,10 +325,10 @@ TEST_F(RPCFeatureHandlerTest, SuccessPathViaHashWithSingleResult) auto const enabled = std::vector{true}; EXPECT_CALL(*mockAmendmentCenterPtr_, getAll).WillOnce(testing::ReturnRef(all)); - EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSEQ)) + EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSeq)) .WillOnce(testing::Return(enabled)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const expectedOutput = fmt::format( @@ -342,8 +342,8 @@ TEST_F(RPCFeatureHandlerTest, SuccessPathViaHashWithSingleResult) "ledger_index": {}, "validated": true }})JSON", - kLEDGER_HASH, - kSEQ + kLedgerHash, + kSeq ); runSpawn([this, &expectedOutput](auto yield) { @@ -371,7 +371,7 @@ TEST_F(RPCFeatureHandlerTest, BadFeaturePath) auto const keys = std::vector{"nonexistent"}; EXPECT_CALL(*mockAmendmentCenterPtr_, getAll).WillOnce(testing::ReturnRef(all)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); runSpawn([this](auto yield) { @@ -403,10 +403,10 @@ TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByNameReturnsSupported auto const enabled = std::vector{false}; EXPECT_CALL(*mockAmendmentCenterPtr_, getAll).WillOnce(testing::ReturnRef(all)); - EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSEQ)) + EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSeq)) .WillOnce(testing::Return(enabled)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const expectedOutput = fmt::format( @@ -421,8 +421,8 @@ TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByNameReturnsSupported "validated": true }})JSON", ownerPaysFeeKey, - kLEDGER_HASH, - kSEQ + kLedgerHash, + kSeq ); runSpawn([this, &expectedOutput](auto yield) { @@ -451,10 +451,10 @@ TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByHashReturnsSupported auto const enabled = std::vector{true}; EXPECT_CALL(*mockAmendmentCenterPtr_, getAll).WillOnce(testing::ReturnRef(all)); - EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSEQ)) + EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSeq)) .WillOnce(testing::Return(enabled)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const expectedOutput = fmt::format( @@ -469,8 +469,8 @@ TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByHashReturnsSupported "validated": true }})JSON", ownerPaysFeeKey, - kLEDGER_HASH, - kSEQ + kLedgerHash, + kSeq ); runSpawn([this, &ownerPaysFeeKey, &expectedOutput](auto yield) { @@ -506,10 +506,10 @@ TEST_F(RPCFeatureHandlerTest, SuccessPathWithMultipleResults) auto const enabled = std::vector{true, false}; EXPECT_CALL(*mockAmendmentCenterPtr_, getAll).WillOnce(testing::ReturnRef(all)); - EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSEQ)) + EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, keys, kSeq)) .WillOnce(testing::Return(enabled)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader)); auto const amendments = createAmendmentsObject( @@ -534,8 +534,8 @@ TEST_F(RPCFeatureHandlerTest, SuccessPathWithMultipleResults) "ledger_index": {}, "validated": true }})JSON", - kLEDGER_HASH, - kSEQ + kLedgerHash, + kSeq ); runSpawn([this, &expectedOutput](auto yield) { diff --git a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp index 0e946aec3..8088ca4e1 100644 --- a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp +++ b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp @@ -33,15 +33,15 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kACCOUNT3 = "raHGBERMka3KZsfpTQUAtumxmvpqhFLyrk"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kTXN_ID = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; -constexpr auto kAPI_VERSION = 2; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount3 = "raHGBERMka3KZsfpTQUAtumxmvpqhFLyrk"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kTxnId = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; +constexpr auto kApiVersion = 2; struct ParameterTestBundle { std::string testName; @@ -111,7 +111,7 @@ generateParameterTestBundles() "account": "{}", "ledger_index": "meh" }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "ledgerIndexMalformed" @@ -123,7 +123,7 @@ generateParameterTestBundles() "account": "{}", "ledger_hash": "meh" }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "ledger_hashMalformed" @@ -135,7 +135,7 @@ generateParameterTestBundles() "account": "{}", "ledger_hash": 12 }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "ledger_hashNotString" @@ -147,7 +147,7 @@ generateParameterTestBundles() "account": "{}", "hotwallet": 12 }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidHotWallet", .expectedErrorMessage = "hotwalletNotStringOrArray" @@ -159,7 +159,7 @@ generateParameterTestBundles() "account": "{}", "hotwallet": [12] }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidHotWallet", .expectedErrorMessage = "hotwalletMalformed" @@ -171,7 +171,7 @@ generateParameterTestBundles() "account": "{}", "hotwallet": ["12"] }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidHotWallet", .expectedErrorMessage = "hotwalletMalformed" @@ -183,7 +183,7 @@ generateParameterTestBundles() "account": "{}", "hotwallet": "12" }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidHotWallet", .expectedErrorMessage = "hotwalletMalformed" @@ -195,11 +195,11 @@ generateParameterTestBundles() "account": "{}", "hotwallet": 12 }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "hotwalletNotStringOrArray", - .apiVersion = kAPI_VERSION + .apiVersion = kApiVersion }, ParameterTestBundle{ .testName = "WalletsNotStringAccountV2", @@ -208,11 +208,11 @@ generateParameterTestBundles() "account": "{}", "hotwallet": [12] }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "hotwalletMalformed", - .apiVersion = kAPI_VERSION + .apiVersion = kApiVersion }, ParameterTestBundle{ .testName = "WalletsInvalidAccountV2", @@ -221,11 +221,11 @@ generateParameterTestBundles() "account": "{}", "hotwallet": ["12"] }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "hotwalletMalformed", - .apiVersion = kAPI_VERSION + .apiVersion = kApiVersion }, ParameterTestBundle{ .testName = "WalletInvalidAccountV2", @@ -234,11 +234,11 @@ generateParameterTestBundles() "account": "{}", "hotwallet": "12" }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "hotwalletMalformed", - .apiVersion = kAPI_VERSION + .apiVersion = kApiVersion }, }; } @@ -247,7 +247,7 @@ INSTANTIATE_TEST_SUITE_P( RPCGatewayBalancesHandler, ParameterTest, testing::ValuesIn(generateParameterTestBundles()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaStringIndex) @@ -266,7 +266,7 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaStringIndex) "account": "{}", "ledger_index": "{}" }})JSON", - kACCOUNT, + kAccount, seq ) ), @@ -295,7 +295,7 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) "account": "{}", "ledger_index": {} }})JSON", - kACCOUNT, + kAccount, seq ) ), @@ -310,7 +310,7 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillOnce(Return(std::optional{})); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; @@ -322,8 +322,8 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaHash) "account": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ), Context{yield} @@ -339,10 +339,10 @@ TEST_F(RPCGatewayBalancesHandlerTest, AccountNotFound) { auto const seq = 300; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)) .WillOnce(Return(std::optional{})); @@ -354,7 +354,7 @@ TEST_F(RPCGatewayBalancesHandlerTest, AccountNotFound) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ), Context{yield} @@ -383,17 +383,17 @@ TEST_P(NormalPathTest, CheckOutput) auto const seq = 300; // return valid ledgerHeader - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); // return valid owner dir - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, seq, _)) .WillOnce(Return(bundle.mockedDir.getSerializer().peekData())); @@ -412,7 +412,7 @@ TEST_P(NormalPathTest, CheckOutput) "account": "{}", {} }})JSON", - kACCOUNT, + kAccount, bundle.hotwallet ) ), @@ -427,50 +427,49 @@ static auto generateNormalPathTestBundles() { auto frozenState = createRippleStateLedgerObject( - "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 + "JPY", kIssuer, -50, kAccount, 10, kAccount3, 20, kTxnId, 123 ); frozenState.setFieldU32(ripple::sfFlags, ripple::lsfLowFreeze); - auto overflowState = createRippleStateLedgerObject( - "JPY", kISSUER, 50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 - ); + auto overflowState = + createRippleStateLedgerObject("JPY", kIssuer, 50, kAccount, 10, kAccount3, 20, kTxnId, 123); int64_t const min64 = -9922966390934554; overflowState.setFieldAmount( - ripple::sfBalance, ripple::STAmount(getIssue("JPY", kISSUER), min64, 80) + ripple::sfBalance, ripple::STAmount(getIssue("JPY", kIssuer), min64, 80) ); return std::vector{ NormalTestBundle{ .testName = "AllBranches", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}}, - kINDEX1 + {ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}}, + kIndex1 ), .mockedObjects = std::vector{ // hotwallet createRippleStateLedgerObject( - "USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kIssuer, -10, kAccount, 100, kAccount2, 200, kTxnId, 123 ), // hotwallet createRippleStateLedgerObject( - "CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "CNY", kIssuer, -20, kAccount, 100, kAccount2, 200, kTxnId, 123 ), // positive balance -> asset createRippleStateLedgerObject( - "EUR", kISSUER, 30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123 + "EUR", kIssuer, 30, kAccount, 100, kAccount3, 200, kTxnId, 123 ), // positive balance -> asset createRippleStateLedgerObject( - "JPY", kISSUER, 40, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123 + "JPY", kIssuer, 40, kAccount, 100, kAccount3, 200, kTxnId, 123 ), // obligation createRippleStateLedgerObject( - "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 + "JPY", kIssuer, -50, kAccount, 10, kAccount3, 20, kTxnId, 123 ), frozenState @@ -516,18 +515,18 @@ generateNormalPathTestBundles() "ledger_index": 300, "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652" }})JSON", - kACCOUNT2, - kACCOUNT3, - kACCOUNT3, - kACCOUNT + kAccount2, + kAccount3, + kAccount3, + kAccount ), - .hotwallet = fmt::format(R"("hotwallet": "{}")", kACCOUNT2) + .hotwallet = fmt::format(R"("hotwallet": "{}")", kAccount2) }, NormalTestBundle{ .testName = "NoHotwallet", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1), .mockedObjects = std::vector{createRippleStateLedgerObject( - "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 + "JPY", kIssuer, -50, kAccount, 10, kAccount3, 20, kTxnId, 123 )}, .expectedJson = fmt::format( R"JSON({{ @@ -538,14 +537,14 @@ generateNormalPathTestBundles() "ledger_index": 300, "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652" }})JSON", - kACCOUNT + kAccount ), .hotwallet = R"("ledger_index" : "validated")" }, NormalTestBundle{ .testName = "ObligationOverflow", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 + {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 ), .mockedObjects = std::vector{overflowState, overflowState}, .expectedJson = fmt::format( @@ -557,34 +556,34 @@ generateNormalPathTestBundles() "ledger_index": 300, "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652" }})JSON", - kACCOUNT + kAccount ), .hotwallet = R"("ledger_index" : "validated")" }, NormalTestBundle{ .testName = "HighID", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}}, - kINDEX1 + {ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}, + ripple::uint256{kIndex2}}, + kIndex1 ), .mockedObjects = std::vector{ // hotwallet createRippleStateLedgerObject( - "USD", kISSUER, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 + "USD", kIssuer, 10, kAccount2, 100, kAccount, 200, kTxnId, 123 ), // hotwallet createRippleStateLedgerObject( - "CNY", kISSUER, 20, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 + "CNY", kIssuer, 20, kAccount2, 100, kAccount, 200, kTxnId, 123 ), createRippleStateLedgerObject( - "EUR", kISSUER, 30, kACCOUNT3, 100, kACCOUNT, 200, kTXN_ID, 123 + "EUR", kIssuer, 30, kAccount3, 100, kAccount, 200, kTxnId, 123 ), createRippleStateLedgerObject( - "JPY", kISSUER, -50, kACCOUNT3, 10, kACCOUNT, 20, kTXN_ID, 123 + "JPY", kIssuer, -50, kAccount3, 10, kAccount, 20, kTxnId, 123 ) }, .expectedJson = fmt::format( @@ -616,28 +615,28 @@ generateNormalPathTestBundles() "ledger_index": 300, "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652" }})JSON", - kACCOUNT2, - kACCOUNT3, - kACCOUNT + kAccount2, + kAccount3, + kAccount ), - .hotwallet = fmt::format(R"("hotwallet": "{}")", kACCOUNT2) + .hotwallet = fmt::format(R"("hotwallet": "{}")", kAccount2) }, NormalTestBundle{ .testName = "HotWalletArray", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, - kINDEX1 + {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, + kIndex1 ), .mockedObjects = std::vector{ createRippleStateLedgerObject( - "USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kIssuer, -10, kAccount, 100, kAccount2, 200, kTxnId, 123 ), createRippleStateLedgerObject( - "CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "CNY", kIssuer, -20, kAccount, 100, kAccount2, 200, kTxnId, 123 ), createRippleStateLedgerObject( - "EUR", kISSUER, -30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123 + "EUR", kIssuer, -30, kAccount, 100, kAccount3, 200, kTxnId, 123 ) }, @@ -665,11 +664,11 @@ generateNormalPathTestBundles() "ledger_index": 300, "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652" }})JSON", - kACCOUNT3, - kACCOUNT2, - kACCOUNT + kAccount3, + kAccount2, + kAccount ), - .hotwallet = fmt::format(R"("hotwallet": ["{}", "{}"])", kACCOUNT2, kACCOUNT3) + .hotwallet = fmt::format(R"("hotwallet": ["{}", "{}"])", kAccount2, kAccount3) }, }; } @@ -678,7 +677,7 @@ INSTANTIATE_TEST_SUITE_P( RPCGatewayBalancesHandler, NormalPathTest, testing::ValuesIn(generateNormalPathTestBundles()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct EscrowTestBundle { @@ -696,14 +695,14 @@ TEST_P(EscrowTest, CheckEscrowOutput) auto const& bundle = GetParam(); auto const seq = 300; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, seq, _)) .WillOnce(Return(bundle.mockedDir.getSerializer().peekData())); @@ -721,7 +720,7 @@ TEST_P(EscrowTest, CheckEscrowOutput) R"JSON({{ "account": "{}" }})JSON", - kACCOUNT + kAccount ) ), Context{yield} @@ -735,21 +734,21 @@ static auto generateEscrowTestBundles() { // Escrow with 100 XRP - auto escrow1 = createEscrowLedgerObject(kACCOUNT, kACCOUNT2); + auto escrow1 = createEscrowLedgerObject(kAccount, kAccount2); escrow1.setFieldAmount(ripple::sfAmount, ripple::STAmount(100, false)); // Escrow with 200 XRP - auto escrow2 = createEscrowLedgerObject(kACCOUNT, kACCOUNT3); + auto escrow2 = createEscrowLedgerObject(kAccount, kAccount3); escrow2.setFieldAmount(ripple::sfAmount, ripple::STAmount(200, false)); // Escrow with a non-XRP currency - auto escrow3 = createEscrowLedgerObject(kACCOUNT, kACCOUNT2); - escrow3.setFieldAmount(ripple::sfAmount, ripple::STAmount(getIssue("USD", kISSUER), 50)); + auto escrow3 = createEscrowLedgerObject(kAccount, kAccount2); + escrow3.setFieldAmount(ripple::sfAmount, ripple::STAmount(getIssue("USD", kIssuer), 50)); return std::vector{ EscrowTestBundle{ .testName = "SingleEscrowXRP", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1), .mockedObjects = std::vector{escrow1}, .expectedJson = fmt::format( R"JSON({{ @@ -758,14 +757,14 @@ generateEscrowTestBundles() "ledger_index": 300, "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) }, EscrowTestBundle{ .testName = "MultipleEscrowXRP", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 + {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 ), .mockedObjects = std::vector{escrow1, escrow2}, .expectedJson = fmt::format( @@ -775,13 +774,13 @@ generateEscrowTestBundles() "ledger_index": 300, "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) }, EscrowTestBundle{ .testName = "EscrowNonXRP", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1), .mockedObjects = std::vector{escrow3}, .expectedJson = fmt::format( R"JSON({{ @@ -790,15 +789,15 @@ generateEscrowTestBundles() "ledger_index": 300, "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) }, EscrowTestBundle{ .testName = "EscrowMixedCurrencies", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, - kINDEX1 + {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, + kIndex1 ), .mockedObjects = std::vector{escrow1, escrow2, escrow3}, .expectedJson = fmt::format( @@ -808,8 +807,8 @@ generateEscrowTestBundles() "ledger_index": 300, "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) } }; @@ -819,5 +818,5 @@ INSTANTIATE_TEST_SUITE_P( RPCGatewayBalancesHandler, EscrowTest, testing::ValuesIn(generateEscrowTestBundles()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); diff --git a/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp b/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp index e0e12e642..71f5a9346 100644 --- a/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp +++ b/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp @@ -29,13 +29,13 @@ using namespace testing; namespace { -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kTX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kTX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kINDEX = "13F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8"; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kTx1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kTx2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kIndex = "13F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8"; void mockLedgerObject( @@ -55,7 +55,7 @@ mockLedgerObject( time, ripple::Blob(8, 'a'), ripple::Blob(8, 'a'), - kRANGE_MAX - 4, + kRangeMax - 4, ripple::uint256{tx}, createPriceDataSeries({createOraclePriceData( price, ripple::to_currency("USD"), ripple::to_currency("XRP"), scale @@ -63,7 +63,7 @@ mockLedgerObject( ); auto const oracleIndex = ripple::keylet::oracle(getAccountIdWithString(account), docId).key; - EXPECT_CALL(backend, doFetchLedgerObject(oracleIndex, kRANGE_MAX, _)) + EXPECT_CALL(backend, doFetchLedgerObject(oracleIndex, kRangeMax, _)) .WillOnce(Return(oracleObject.getSerializer().peekData())); } }; // namespace @@ -72,7 +72,7 @@ class RPCGetAggregatePriceHandlerTest : public HandlerBaseTest { protected: RPCGetAggregatePriceHandlerTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } }; @@ -378,7 +378,7 @@ INSTANTIATE_TEST_CASE_P( RPCGetAggregatePriceGroup1, GetAggregatePriceParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(GetAggregatePriceParameterTest, InvalidParams) @@ -425,8 +425,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OverOraclesMax) TEST_F(RPCGetAggregatePriceHandlerTest, LedgerNotFound) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(std::nullopt)); - constexpr auto kDOCUMENT_ID = 1; + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillOnce(Return(std::nullopt)); + constexpr auto kDocumentId = 1; auto const req = json::parse( fmt::format( R"JSON({{ @@ -439,8 +439,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, LedgerNotFound) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; @@ -455,11 +455,11 @@ TEST_F(RPCGetAggregatePriceHandlerTest, LedgerNotFound) TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + constexpr auto kDocumentId = 1; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -474,8 +474,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -493,8 +493,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -506,11 +506,11 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + constexpr auto kDocumentId = 1; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -525,8 +525,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -544,8 +544,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -557,11 +557,11 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + constexpr auto kDocumentId = 1; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -576,8 +576,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -595,8 +595,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -610,25 +610,25 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + constexpr auto kDocumentId = 1; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTx1), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( - kACCOUNT, - kRANGE_MAX, + kAccount, + kRangeMax, 123, 1, 4321u, createPriceDataSeries({createOraclePriceData( 1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2 )}), - kINDEX, + kIndex, true, - kTX2 + kTx2 ))); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; @@ -644,8 +644,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -663,8 +663,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -679,15 +679,15 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) // median is the middle value of a set of numbers when there are odd number of price TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -710,12 +710,12 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3 + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3 ) ); @@ -733,8 +733,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -747,17 +747,17 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) // median is the middle value of a set of numbers when there are odd number of price TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - constexpr auto kDOCUMENT_ID4 = 4; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID4, kTX1, 4e2, 1); // 40 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + constexpr auto kDocumentID4 = 4; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID4, kTx1, 4e2, 1); // 40 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -784,14 +784,14 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3, - kACCOUNT, - kDOCUMENT_ID4 + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3, + kAccount, + kDocumentID4 ) ); @@ -809,8 +809,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -822,19 +822,19 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); // prepare 4 prices, when trim is 25, the lowest(documentId1) and highest(documentId3) price // will be removed - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - constexpr auto kDOCUMENT_ID4 = 4; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID4, kTX1, 4e2, 1); // 40 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + constexpr auto kDocumentID4 = 4; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID4, kTx1, 4e2, 1); // 40 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -863,14 +863,14 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) ] }})JSON", 25, - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3, - kACCOUNT, - kDOCUMENT_ID4 + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3, + kAccount, + kDocumentID4 ) ); @@ -893,8 +893,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -906,13 +906,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) TEST_F(RPCGetAggregatePriceHandlerTest, NoOracleEntryFound) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; + constexpr auto kDocumentId = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(oracleIndex, kRANGE_MAX, _)) + ripple::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; + EXPECT_CALL(*backend_, doFetchLedgerObject(oracleIndex, kRangeMax, _)) .WillOnce(Return(std::nullopt)); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; @@ -928,8 +928,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoOracleEntryFound) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -944,11 +944,11 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoOracleEntryFound) TEST_F(RPCGetAggregatePriceHandlerTest, NoMatchAssetPair) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + constexpr auto kDocumentId = 1; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -963,8 +963,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoMatchAssetPair) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -979,21 +979,21 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoMatchAssetPair) TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - constexpr auto kDOCUMENT_ID4 = 4; - constexpr auto kTIMESTAMP1 = 1711461384u; - constexpr auto kTIMESTAMP2 = 1711461383u; - constexpr auto kTIMESTAMP3 = 1711461382u; - constexpr auto kTIMESTAMP4 = 1711461381u; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2, kTIMESTAMP1); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2, kTIMESTAMP2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID4, kTX1, 4e2, 1, kTIMESTAMP3); // 40 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + constexpr auto kDocumentID4 = 4; + constexpr auto kTimestamp1 = 1711461384u; + constexpr auto kTimestamp2 = 1711461383u; + constexpr auto kTimestamp3 = 1711461382u; + constexpr auto kTimestamp4 = 1711461381u; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2, kTimestamp1); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2, kTimestamp2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID4, kTx1, 4e2, 1, kTimestamp3); // 40 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1, kTimestamp4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -1022,14 +1022,14 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) ] }})JSON", 0, - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3, - kACCOUNT, - kDOCUMENT_ID4 + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3, + kAccount, + kDocumentID4 ) ); @@ -1047,9 +1047,9 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) "ledger_hash": "{}", "validated": true }})JSON", - kTIMESTAMP1, - kRANGE_MAX, - kLEDGER_HASH + kTimestamp1, + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -1061,21 +1061,21 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - constexpr auto kDOCUMENT_ID4 = 4; - constexpr auto kTIMESTAMP1 = 1711461384u; - constexpr auto kTIMESTAMP2 = 1711461383u; - constexpr auto kTIMESTAMP3 = 1711461382u; - constexpr auto kTIMESTAMP4 = 1711461381u; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2, kTIMESTAMP1); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2, kTIMESTAMP2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID4, kTX1, 4e2, 1, kTIMESTAMP3); // 40 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + constexpr auto kDocumentID4 = 4; + constexpr auto kTimestamp1 = 1711461384u; + constexpr auto kTimestamp2 = 1711461383u; + constexpr auto kTimestamp3 = 1711461382u; + constexpr auto kTimestamp4 = 1711461381u; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2, kTimestamp1); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2, kTimestamp2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID4, kTx1, 4e2, 1, kTimestamp3); // 40 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1, kTimestamp4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -1103,15 +1103,15 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) }} ] }})JSON", - kTIMESTAMP1 - kTIMESTAMP2, - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3, - kACCOUNT, - kDOCUMENT_ID4 + kTimestamp1 - kTimestamp2, + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3, + kAccount, + kDocumentID4 ) ); @@ -1129,9 +1129,9 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) "ledger_hash": "{}", "validated": true }})JSON", - kTIMESTAMP1, - kRANGE_MAX, - kLEDGER_HASH + kTimestamp1, + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -1143,21 +1143,21 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - constexpr auto kDOCUMENT_ID4 = 4; - constexpr auto kTIMESTAMP1 = 1711461384u; - constexpr auto kTIMESTAMP2 = 1711461383u; - constexpr auto kTIMESTAMP3 = 1711461382u; - constexpr auto kTIMESTAMP4 = 1711461381u; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2, kTIMESTAMP1); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2, kTIMESTAMP2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID4, kTX1, 4e2, 1, kTIMESTAMP3); // 40 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + constexpr auto kDocumentID4 = 4; + constexpr auto kTimestamp1 = 1711461384u; + constexpr auto kTimestamp2 = 1711461383u; + constexpr auto kTimestamp3 = 1711461382u; + constexpr auto kTimestamp4 = 1711461381u; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2, kTimestamp1); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2, kTimestamp2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID4, kTx1, 4e2, 1, kTimestamp3); // 40 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1, kTimestamp4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -1185,15 +1185,15 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) }} ] }})JSON", - kTIMESTAMP1 + 1, - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3, - kACCOUNT, - kDOCUMENT_ID4 + kTimestamp1 + 1, + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3, + kAccount, + kDocumentID4 ) ); @@ -1211,8 +1211,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -1224,21 +1224,21 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID1 = 1; - constexpr auto kDOCUMENT_ID2 = 2; - constexpr auto kDOCUMENT_ID3 = 3; - constexpr auto kDOCUMENT_ID4 = 4; - constexpr auto kTIMESTAMP1 = 1711461384u; - constexpr auto kTIMESTAMP2 = 1711461383u; - constexpr auto kTIMESTAMP3 = 1711461382u; - constexpr auto kTIMESTAMP4 = 1711461381u; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID1, kTX1, 1e3, 2, kTIMESTAMP1); // 10 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID2, kTX1, 2e3, 2, kTIMESTAMP2); // 20 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID4, kTX1, 4e2, 1, kTIMESTAMP3); // 40 - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 + constexpr auto kDocumentID1 = 1; + constexpr auto kDocumentID2 = 2; + constexpr auto kDocumentID3 = 3; + constexpr auto kDocumentID4 = 4; + constexpr auto kTimestamp1 = 1711461384u; + constexpr auto kTimestamp2 = 1711461383u; + constexpr auto kTimestamp3 = 1711461382u; + constexpr auto kTimestamp4 = 1711461381u; + mockLedgerObject(*backend_, kAccount, kDocumentID1, kTx1, 1e3, 2, kTimestamp1); // 10 + mockLedgerObject(*backend_, kAccount, kDocumentID2, kTx1, 2e3, 2, kTimestamp2); // 20 + mockLedgerObject(*backend_, kAccount, kDocumentID4, kTx1, 4e2, 1, kTimestamp3); // 40 + mockLedgerObject(*backend_, kAccount, kDocumentID3, kTx1, 3e3, 1, kTimestamp4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; auto const req = json::parse( @@ -1266,15 +1266,15 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) }} ] }})JSON", - kTIMESTAMP4 - kTIMESTAMP1, - kACCOUNT, - kDOCUMENT_ID1, - kACCOUNT, - kDOCUMENT_ID2, - kACCOUNT, - kDOCUMENT_ID3, - kACCOUNT, - kDOCUMENT_ID4 + kTimestamp4 - kTimestamp1, + kAccount, + kDocumentID1, + kAccount, + kDocumentID2, + kAccount, + kDocumentID3, + kAccount, + kDocumentID4 ) ); @@ -1292,8 +1292,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -1306,18 +1306,18 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) // When the price pair is not available in the current oracle, trace back to previous transactions TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; + constexpr auto kDocumentId = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + ripple::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 // return a tx which contains NewFields - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTx1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( - kACCOUNT, - kRANGE_MAX, + kAccount, + kRangeMax, 123, 1, 4321u, @@ -1326,7 +1326,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) )}), ripple::to_string(oracleIndex), false, - kTX1 + kTx1 ))); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; @@ -1342,8 +1342,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); @@ -1361,8 +1361,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) "ledger_hash": "{}", "validated": true }})JSON", - kRANGE_MAX, - kLEDGER_HASH + kRangeMax, + kLedgerHash ) ); runSpawn([&](auto yield) { @@ -1373,18 +1373,18 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) } TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - constexpr auto kDOCUMENT_ID = 1; + constexpr auto kDocumentId = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; - mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 + ripple::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; + mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTx1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( - kACCOUNT, - kRANGE_MAX, + kAccount, + kRangeMax, 123, 1, 4321u, @@ -1393,13 +1393,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) )}), ripple::to_string(oracleIndex), false, - kTX2 + kTx2 ))); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX2), _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTx2), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( - kACCOUNT, - kRANGE_MAX, + kAccount, + kRangeMax, 123, 1, 4321u, @@ -1408,7 +1408,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) )}), ripple::to_string(oracleIndex), false, - kTX2 + kTx2 ))); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; @@ -1424,8 +1424,8 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) }} ] }})JSON", - kACCOUNT, - kDOCUMENT_ID + kAccount, + kDocumentId ) ); diff --git a/tests/unit/rpc/handlers/LedgerDataTests.cpp b/tests/unit/rpc/handlers/LedgerDataTests.cpp index c18cdef7b..698dd2a7b 100644 --- a/tests/unit/rpc/handlers/LedgerDataTests.cpp +++ b/tests/unit/rpc/handlers/LedgerDataTests.cpp @@ -28,22 +28,22 @@ using namespace testing; namespace { -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kTXN_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F0DD"; -constexpr auto kAPI_VERSION = 2; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F0DD"; +constexpr auto kApiVersion = 2; } // namespace struct RPCLedgerDataHandlerTest : HandlerBaseTest { RPCLedgerDataHandlerTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } }; @@ -144,7 +144,7 @@ INSTANTIATE_TEST_CASE_P( RPCLedgerDataGroup1, LedgerDataParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(LedgerDataParameterTest, InvalidParams) @@ -164,7 +164,7 @@ TEST_P(LedgerDataParameterTest, InvalidParams) TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; @@ -173,7 +173,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaIntSequence) R"JSON({{ "ledger_index": {} }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -187,7 +187,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaIntSequence) TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; @@ -196,7 +196,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) R"JSON({{ "ledger_index": "{}" }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -210,7 +210,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -220,7 +220,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaHash) R"JSON({{ "ledger_hash": "{}" }})JSON", - kLEDGER_HASH + kLedgerHash ) ); auto const output = handler.process(req, Context{yield}); @@ -234,11 +234,11 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaHash) TEST_F(RPCLedgerDataHandlerTest, MarkerNotExist) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -248,7 +248,7 @@ TEST_F(RPCLedgerDataHandlerTest, MarkerNotExist) R"JSON({{ "marker": "{}" }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); @@ -261,7 +261,7 @@ TEST_F(RPCLedgerDataHandlerTest, MarkerNotExist) TEST_F(RPCLedgerDataHandlerTest, NoMarker) { - static auto const kLEDGER_EXPECTED = R"JSON({ + static auto const kLedgerExpected = R"JSON({ "account_hash": "0000000000000000000000000000000000000000000000000000000000000000", "close_flags": 0, "close_time": 0, @@ -277,7 +277,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) })JSON"; EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); // when 'type' not specified, default to all the types auto limitLine = 5; @@ -285,18 +285,18 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } while ((limitTicket--) != 0) { - auto const ticket = createTicketLedgerObject(kACCOUNT, limitTicket); + auto const ticket = createTicketLedgerObject(kAccount, limitTicket); bbs.push_back(ticket.getSerializer().peekData()); } @@ -312,17 +312,17 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) // Note: the format of "close_time_human" depends on the platform and might differ per // platform. It is however guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); + EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), kIndex2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 10); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, Version2) { - static auto const kLEDGER_EXPECTED = R"JSON({ + static auto const kLedgerExpected = R"JSON({ "account_hash": "0000000000000000000000000000000000000000000000000000000000000000", "close_flags": 0, "close_time": 0, @@ -338,7 +338,7 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) })JSON"; EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + .WillOnce(Return(createLedgerHeader(kLedgerHash, kRangeMax))); // When 'type' not specified, default to all the types auto limitLine = 5; @@ -346,18 +346,18 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } while ((limitTicket--) != 0) { - auto const ticket = createTicketLedgerObject(kACCOUNT, limitTicket); + auto const ticket = createTicketLedgerObject(kAccount, limitTicket); bbs.push_back(ticket.getSerializer().peekData()); } @@ -366,20 +366,20 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; auto const req = json::parse(R"JSON({"limit": 10})JSON"); - auto output = handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + auto output = handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); // Note: the format of "close_time_human" depends on the platform and might differ per // platform. It is however guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); + EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLedgerExpected)); }); } TEST_F(RPCLedgerDataHandlerTest, TypeFilter) { - static auto const kLEDGER_EXPECTED = R"JSON({ + static auto const kLedgerExpected = R"JSON({ "account_hash": "0000000000000000000000000000000000000000000000000000000000000000", "close_flags": 0, "close_time": 0, @@ -395,26 +395,26 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) })JSON"; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); auto limitLine = 5; auto limitTicket = 5; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } while ((limitTicket--) != 0) { - auto const ticket = createTicketLedgerObject(kACCOUNT, limitTicket); + auto const ticket = createTicketLedgerObject(kAccount, limitTicket); bbs.push_back(ticket.getSerializer().peekData()); } @@ -435,17 +435,17 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) // Note: the format of "close_time_human" depends on the platform and might differ per // platform. It is however guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); + EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), kIndex2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 5); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) { - static auto const kLEDGER_EXPECTED = R"JSON({ + static auto const kLedgerExpected = R"JSON({ "account_hash": "0000000000000000000000000000000000000000000000000000000000000000", "close_flags": 0, "close_time": 0, @@ -461,25 +461,25 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) })JSON"; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); auto limitLine = 5; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + 1); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } auto const amm = - createAmmObject(kACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2); + createAmmObject(kAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAccount2); bbs.push_back(amm.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -499,17 +499,17 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) // Note: the format of "close_time_human" depends on the platform and might differ per // platform. It is however guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); + EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), kIndex2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) { - static auto const kLEDGER_EXPECTED = R"JSON({ + static auto const kLedgerExpected = R"JSON({ "account_hash": "0000000000000000000000000000000000000000000000000000000000000000", "close_flags": 0, "close_time": 0, @@ -525,20 +525,20 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) })JSON"; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); // page end // marker return seq std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); - ON_CALL(*backend_, doFetchSuccessorKey(kFIRST_KEY, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX2}, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchSuccessorKey(kFirstKey, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); + ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kIndex2}, kRangeMax, _)) .WillByDefault(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); @@ -552,24 +552,24 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); - EXPECT_EQ(output.result->as_object().at("marker").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("marker").as_uint64(), kRangeMax); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, Marker) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillByDefault(Return(createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ) .getSerializer() .peekData())); @@ -577,14 +577,14 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) auto limit = 10; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX2}, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kIndex1}, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); + ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kIndex2}, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } @@ -600,24 +600,24 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) "limit": 10, "marker": "{}" }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_FALSE(output.result->as_object().contains("ledger")); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), kIndex2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 10); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, DiffMarker) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); auto limit = 10; std::vector los; @@ -627,14 +627,14 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker) while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); los.emplace_back( - LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}} + LedgerObject{.key = ripple::uint256{kIndex2}, .blob = Blob{}} ); // NOLINT(modernize-use-emplace) } - ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los)); + ON_CALL(*backend_, fetchLedgerDiff(kRangeMax, _)).WillByDefault(Return(los)); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); @@ -648,15 +648,15 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker) "marker": {}, "out_of_order": true }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_FALSE(output.result->as_object().contains("ledger")); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 10); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); EXPECT_FALSE(output.result->as_object().at("cache_full").as_bool()); }); } @@ -664,19 +664,19 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker) TEST_F(RPCLedgerDataHandlerTest, Binary) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); auto limit = 10; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } @@ -698,27 +698,27 @@ TEST_F(RPCLedgerDataHandlerTest, Binary) EXPECT_TRUE(output.result->as_object().at("ledger").as_object().contains("ledger_data")); EXPECT_TRUE(output.result->as_object().at("ledger").as_object().at("closed").as_bool()); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 10); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - auto limit = LedgerDataHandler::kLIMIT_BINARY + 1; + auto limit = LedgerDataHandler::kLimitBinary + 1; std::vector bbs; - EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLIMIT_BINARY); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLimitBinary); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limit--) != 0u) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } @@ -734,7 +734,7 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) "limit": {}, "binary": true }})JSON", - LedgerDataHandler::kLIMIT_BINARY + 1 + LedgerDataHandler::kLimitBinary + 1 ) ); auto const output = handler.process(req, Context{yield}); @@ -744,29 +744,29 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) EXPECT_TRUE(output.result->as_object().at("ledger").as_object().at("closed").as_bool()); EXPECT_EQ( output.result->as_object().at("state").as_array().size(), - LedgerDataHandler::kLIMIT_BINARY + LedgerDataHandler::kLimitBinary ); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); - auto limit = LedgerDataHandler::kLIMIT_JSON + 1; + auto limit = LedgerDataHandler::kLimitJson + 1; std::vector bbs; - EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLIMIT_JSON); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLimitJson); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); while ((limit--) != 0u) { auto const line = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); bbs.push_back(line.getSerializer().peekData()); } @@ -782,7 +782,7 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) "limit": {}, "binary": false }})JSON", - LedgerDataHandler::kLIMIT_JSON + 1 + LedgerDataHandler::kLimitJson + 1 ) ); auto const output = handler.process(req, Context{yield}); @@ -790,25 +790,25 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) EXPECT_TRUE(output.result->as_object().contains("ledger")); EXPECT_TRUE(output.result->as_object().at("ledger").as_object().at("closed").as_bool()); EXPECT_EQ( - output.result->as_object().at("state").as_array().size(), LedgerDataHandler::kLIMIT_JSON + output.result->as_object().at("state").as_array().size(), LedgerDataHandler::kLimitJson ); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); }); } TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); - auto const issuance = createMptIssuanceObject(kACCOUNT, 2, "metadata"); + auto const issuance = createMptIssuanceObject(kAccount, 2, "metadata"); bbs.push_back(issuance.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -825,9 +825,9 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), kIndex2); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); auto const& objects = output.result->as_object().at("state").as_array(); EXPECT_EQ(objects.front().at("LedgerEntryType").as_string(), "MPTokenIssuance"); @@ -835,7 +835,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) // make sure mptID is synethetically parsed if object is mptIssuance EXPECT_EQ( objects.front().at("mpt_issuance_id").as_string(), - ripple::to_string(ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))) + ripple::to_string(ripple::makeMptID(2, getAccountIdWithString(kAccount))) ); }); } @@ -843,16 +843,16 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) - .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) + .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) + .WillByDefault(Return(ripple::uint256{kIndex2})); auto const mptoken = - createMpTokenObject(kACCOUNT, ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))); + createMpTokenObject(kAccount, ripple::makeMptID(2, getAccountIdWithString(kAccount))); bbs.push_back(mptoken.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -869,9 +869,9 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken) ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); - EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), kIndex2); + EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(output.result->as_object().at("ledger_index").as_uint64(), kRangeMax); auto const& objects = output.result->as_object().at("state").as_array(); EXPECT_EQ(objects.front().at("LedgerEntryType").as_string(), "MPToken"); diff --git a/tests/unit/rpc/handlers/LedgerEntryTests.cpp b/tests/unit/rpc/handlers/LedgerEntryTests.cpp index 9598266d1..063270fcb 100644 --- a/tests/unit/rpc/handlers/LedgerEntryTests.cpp +++ b/tests/unit/rpc/handlers/LedgerEntryTests.cpp @@ -45,24 +45,24 @@ using namespace testing; namespace { -constexpr auto kINDEX1 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kACCOUNT3 = "rhzcyub9SbyZ4YF1JYskN5rLrTDUuLZG6D"; -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kTOKEN_ID = "000827103B94ECBB7BF0A0A6ED62B3607801A27B65F4679F4AD1D4850000C0EA"; -constexpr auto kNFT_ID = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; -constexpr auto kTXN_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; -constexpr auto kCREDENTIAL_TYPE = "4B5943"; +constexpr auto kIndex1 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount3 = "rhzcyub9SbyZ4YF1JYskN5rLrTDUuLZG6D"; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kTokenId = "000827103B94ECBB7BF0A0A6ED62B3607801A27B65F4679F4AD1D4850000C0EA"; +constexpr auto kNftId = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; +constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kCredentialType = "4B5943"; } // namespace struct RPCLedgerEntryTest : HandlerBaseTest { RPCLedgerEntryTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } }; @@ -197,7 +197,7 @@ generateTestValuesForParametersTest() "authorized": 123 }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "authorizedNotString" @@ -212,7 +212,7 @@ generateTestValuesForParametersTest() "authorized_credentials": "asdf" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "authorized_credentials not array" @@ -227,7 +227,7 @@ generateTestValuesForParametersTest() "authorized_credentials": ["C2F2A19C8D0D893D18F18FDCFE13A3ECB41767E48422DF07F2455CDA08FDF09B"] }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "authorized_credentials elements in array are not objects." @@ -241,7 +241,7 @@ generateTestValuesForParametersTest() "owner": "{}" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Must have one of authorized or authorized_credentials." @@ -262,10 +262,10 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2, - kACCOUNT3, - kCREDENTIAL_TYPE + kAccount, + kAccount2, + kAccount3, + kCredentialType ), .expectedError = "malformedRequest", .expectedErrorMessage = "Must have one of authorized or authorized_credentials." @@ -281,7 +281,7 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "Requires at least one element in authorized_credentials array." @@ -300,8 +300,8 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "Field 'CredentialType' is required but missing." @@ -320,8 +320,8 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kCREDENTIAL_TYPE + kAccount, + kCredentialType ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "Field 'Issuer' is required but missing." @@ -341,8 +341,8 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kCREDENTIAL_TYPE + kAccount, + kCredentialType ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "issuer NotString" @@ -362,8 +362,8 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "credential_type NotString" @@ -383,8 +383,8 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "credential_type NotHexString" @@ -404,8 +404,8 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "credential_type is empty" @@ -429,11 +429,11 @@ generateTestValuesForParametersTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2, - kCREDENTIAL_TYPE, - kACCOUNT2, - kCREDENTIAL_TYPE + kAccount, + kAccount2, + kCredentialType, + kAccount2, + kCredentialType ), .expectedError = "malformedAuthorizedCredentials", .expectedErrorMessage = "duplicates in credentials." @@ -499,7 +499,7 @@ generateTestValuesForParametersTest() "ticket_seq": "123" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -565,7 +565,7 @@ generateTestValuesForParametersTest() "seq": "123" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -631,7 +631,7 @@ generateTestValuesForParametersTest() "seq": "123" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -674,7 +674,7 @@ generateTestValuesForParametersTest() "accounts": ["{}"] }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "malformedAccounts" @@ -689,8 +689,8 @@ generateTestValuesForParametersTest() "currency": "USD" }} }})JSON", - kACCOUNT, - kACCOUNT + kAccount, + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "malformedAccounts" @@ -705,7 +705,7 @@ generateTestValuesForParametersTest() "currency": "USD" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "malformedAccounts" @@ -720,7 +720,7 @@ generateTestValuesForParametersTest() "currency": "USD" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedAddress", .expectedErrorMessage = "malformedAddresses" @@ -735,8 +735,8 @@ generateTestValuesForParametersTest() "currency": "XXXX" }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedCurrency", .expectedErrorMessage = "malformedCurrency" @@ -751,8 +751,8 @@ generateTestValuesForParametersTest() "currency": 123 }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "invalidParams", .expectedErrorMessage = "currencyNotString" @@ -838,8 +838,8 @@ generateTestValuesForParametersTest() "owner": "{}" }} }})JSON", - kINDEX1, - kACCOUNT + kIndex1, + kAccount ), .expectedError = "invalidParams", .expectedErrorMessage = "mayNotSpecifyBothDirRootAndOwner" @@ -854,7 +854,7 @@ generateTestValuesForParametersTest() "sub_index": "not int" }} }})JSON", - kINDEX1 + kIndex1 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -902,7 +902,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -920,7 +920,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -937,7 +937,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -954,7 +954,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -972,7 +972,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -990,7 +990,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1010,7 +1010,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1030,7 +1030,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1050,7 +1050,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1071,8 +1071,8 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT + kAccount, + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1091,7 +1091,7 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1112,10 +1112,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1137,11 +1137,11 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, + kAccount, 1, - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1163,9 +1163,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, + kAccount, "JPY", 2 ), @@ -1186,9 +1186,9 @@ generateTestValuesForParametersTest() "IssuingChainIssue": 1 }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT + kAccount, + kAccount, + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1210,10 +1210,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1235,10 +1235,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1260,9 +1260,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, + kAccount, "JPY" ), .expectedError = "malformedRequest", @@ -1285,10 +1285,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT2, - kACCOUNT2 + kAccount, + kAccount, + kAccount2, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1311,11 +1311,11 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT2, - kACCOUNT2, - kACCOUNT2 + kAccount, + kAccount, + kAccount2, + kAccount2, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1336,9 +1336,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1360,10 +1360,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT2, - kACCOUNT2, - kACCOUNT2 + kAccount, + kAccount2, + kAccount2, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1384,9 +1384,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1405,10 +1405,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount, + kAccount, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1427,10 +1427,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount, + kAccount, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1442,7 +1442,7 @@ generateTestValuesForParametersTest() "bridge_account": "{}", "bridge": "invalid" }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1471,10 +1471,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1495,9 +1495,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1515,8 +1515,8 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT + kAccount, + kAccount ), .expectedError = "malformedRequest", @@ -1539,9 +1539,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1562,8 +1562,8 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY" ), .expectedError = "malformedRequest", @@ -1593,10 +1593,10 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1617,9 +1617,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1637,8 +1637,8 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT + kAccount, + kAccount ), .expectedError = "malformedRequest", @@ -1661,9 +1661,9 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, + kAccount, "JPY", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1684,8 +1684,8 @@ generateTestValuesForParametersTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, + kAccount, + kAccount, "JPY" ), .expectedError = "malformedRequest", @@ -1699,7 +1699,7 @@ generateTestValuesForParametersTest() "account": "{}" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1713,7 +1713,7 @@ generateTestValuesForParametersTest() "oracle_document_id": -1 }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedDocumentID", .expectedErrorMessage = "Malformed oracle_document_id." @@ -1727,7 +1727,7 @@ generateTestValuesForParametersTest() "oracle_document_id": "invalid" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedDocumentID", .expectedErrorMessage = "Malformed oracle_document_id." @@ -1741,7 +1741,7 @@ generateTestValuesForParametersTest() "oracle_document_id": 3.21 }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedDocumentID", .expectedErrorMessage = "Malformed oracle_document_id." @@ -1755,7 +1755,7 @@ generateTestValuesForParametersTest() "oracle_document_id": {{}} }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedDocumentID", .expectedErrorMessage = "Malformed oracle_document_id." @@ -1769,7 +1769,7 @@ generateTestValuesForParametersTest() "oracle_document_id": [] }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedDocumentID", .expectedErrorMessage = "Malformed oracle_document_id." @@ -1783,7 +1783,7 @@ generateTestValuesForParametersTest() "oracle_document_id": null }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedDocumentID", .expectedErrorMessage = "Malformed oracle_document_id." @@ -1922,7 +1922,7 @@ generateTestValuesForParametersTest() "issuer": ["{}"] }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1969,7 +1969,7 @@ generateTestValuesForParametersTest() "account": "{}" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1984,8 +1984,8 @@ generateTestValuesForParametersTest() "credential_type": 1234 }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -1999,8 +1999,8 @@ generateTestValuesForParametersTest() "credential_type": "1234" }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -2058,7 +2058,7 @@ generateTestValuesForParametersTest() R"JSON({{ "permissioned_domain": {{ "account": "{}" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request.", @@ -2069,7 +2069,7 @@ generateTestValuesForParametersTest() R"JSON({{ "permissioned_domain": {{ "account": "{}", "seq": -1 }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request.", @@ -2199,7 +2199,7 @@ generateTestValuesForParametersTest() "seq": "notAnInteger" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request.", @@ -2259,7 +2259,7 @@ generateTestValuesForParametersTest() R"JSON({{ "loan": {{ "loan_broker_id": "{}" }} }})JSON", - kINDEX1 + kIndex1 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request.", @@ -2273,7 +2273,7 @@ generateTestValuesForParametersTest() "loan_seq": "notAnInteger" }} }})JSON", - kINDEX1 + kIndex1 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request.", @@ -2299,7 +2299,7 @@ generateTestValuesForParametersTest() "loan_seq": -200 }} }})JSON", - kINDEX1 + kIndex1 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request.", @@ -2330,7 +2330,7 @@ generateTestValuesForParametersTest() "authorize": "{}" }} }})JSON", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -2344,7 +2344,7 @@ generateTestValuesForParametersTest() "authorize": "{}" }} }})JSON", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedAddress", .expectedErrorMessage = "Malformed address." @@ -2358,7 +2358,7 @@ generateTestValuesForParametersTest() "authorize": "{}" }} }})JSON", - kACCOUNT2 + kAccount2 ), .expectedError = "malformedAddress", .expectedErrorMessage = "Malformed address." @@ -2371,7 +2371,7 @@ generateTestValuesForParametersTest() "account": "{}" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedRequest", .expectedErrorMessage = "Malformed request." @@ -2385,7 +2385,7 @@ generateTestValuesForParametersTest() "authorize": 123 }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedAddress", .expectedErrorMessage = "Malformed address." @@ -2399,7 +2399,7 @@ generateTestValuesForParametersTest() "authorize": "invalid_address" }} }})JSON", - kACCOUNT + kAccount ), .expectedError = "malformedAddress", .expectedErrorMessage = "Malformed address." @@ -2411,7 +2411,7 @@ INSTANTIATE_TEST_CASE_P( RPCLedgerEntryGroup1, LedgerEntryParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(LedgerEntryParameterTest, InvalidParams) @@ -2507,13 +2507,13 @@ TEST_P(IndexTest, InvalidIndexNotString) TEST_F(RPCLedgerEntryTest, LedgerEntryNotFound) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); // return null for ledger entry - auto const key = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(key, kRANGE_MAX, _)) + auto const key = ripple::keylet::account(getAccountIdWithString(kAccount)).key; + EXPECT_CALL(*backend_, doFetchLedgerObject(key, kRangeMax, _)) .WillRepeatedly(Return(std::optional{})); runSpawn([&, this](auto yield) { @@ -2523,7 +2523,7 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotFound) R"JSON({{ "account_root": "{}" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(req, Context{yield}); @@ -2546,8 +2546,8 @@ struct RPCLedgerEntryNormalPathTest : public RPCLedgerEntryTest, static auto generateTestValuesForNormalPathTest() { - auto account1 = getAccountIdWithString(kACCOUNT); - auto account2 = getAccountIdWithString(kACCOUNT2); + auto account1 = getAccountIdWithString(kAccount); + auto account2 = getAccountIdWithString(kAccount2); ripple::Currency currency; ripple::to_currency(currency, "USD"); @@ -2559,11 +2559,11 @@ generateTestValuesForNormalPathTest() "binary": true, "index": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = - createAccountRootObject(kACCOUNT2, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) + createAccountRootObject(kAccount2, ripple::lsfGlobalFreeze, 1, 10, 2, kIndex1, 3) }, NormalPathTestBundle{ .testName = "Payment_channel", @@ -2572,11 +2572,11 @@ generateTestValuesForNormalPathTest() "binary": true, "payment_channel": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400) + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 200, 300, kIndex1, 400) }, NormalPathTestBundle{ .testName = "Nft_page", @@ -2585,11 +2585,11 @@ generateTestValuesForNormalPathTest() "binary": true, "nft_page": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = createNftTokenPage( - std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, + std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt ) }, @@ -2600,10 +2600,10 @@ generateTestValuesForNormalPathTest() "binary": true, "check": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createCheckLedgerObject(kACCOUNT, kACCOUNT2) + .expectedIndex = ripple::uint256{kIndex1}, + .mockedEntity = createCheckLedgerObject(kAccount, kAccount2) }, NormalPathTestBundle{ .testName = "DirectoryIndex", @@ -2612,11 +2612,11 @@ generateTestValuesForNormalPathTest() "binary": true, "directory": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{ripple::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2626,18 +2626,18 @@ generateTestValuesForNormalPathTest() "binary": true, "offer": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = createOfferLedgerObject( - kACCOUNT, + kAccount, 100, 200, "USD", "XRP", - kACCOUNT2, + kAccount2, ripple::toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ) }, NormalPathTestBundle{ @@ -2647,10 +2647,10 @@ generateTestValuesForNormalPathTest() "binary": true, "escrow": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createEscrowLedgerObject(kACCOUNT, kACCOUNT2) + .expectedIndex = ripple::uint256{kIndex1}, + .mockedEntity = createEscrowLedgerObject(kAccount, kAccount2) }, NormalPathTestBundle{ .testName = "TicketIndex", @@ -2659,10 +2659,10 @@ generateTestValuesForNormalPathTest() "binary": true, "ticket": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createTicketLedgerObject(kACCOUNT, 0) + .expectedIndex = ripple::uint256{kIndex1}, + .mockedEntity = createTicketLedgerObject(kAccount, 0) }, NormalPathTestBundle{ .testName = "DepositPreauthIndex", @@ -2671,10 +2671,10 @@ generateTestValuesForNormalPathTest() "binary": true, "deposit_preauth": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createDepositPreauthLedgerObjectByAuth(kACCOUNT, kACCOUNT2) + .expectedIndex = ripple::uint256{kIndex1}, + .mockedEntity = createDepositPreauthLedgerObjectByAuth(kAccount, kAccount2) }, NormalPathTestBundle{ .testName = "AccountRoot", @@ -2683,10 +2683,10 @@ generateTestValuesForNormalPathTest() "binary": true, "account_root": "{}" }})JSON", - kACCOUNT + kAccount ), - .expectedIndex = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, - .mockedEntity = createAccountRootObject(kACCOUNT, 0, 1, 1, 1, kINDEX1, 1) + .expectedIndex = ripple::keylet::account(getAccountIdWithString(kAccount)).key, + .mockedEntity = createAccountRootObject(kAccount, 0, 1, 1, 1, kIndex1, 1) }, NormalPathTestBundle{ .testName = "DID", @@ -2695,10 +2695,10 @@ generateTestValuesForNormalPathTest() "binary": true, "did": "{}" }})JSON", - kACCOUNT + kAccount ), - .expectedIndex = ripple::keylet::did(getAccountIdWithString(kACCOUNT)).key, - .mockedEntity = createDidObject(kACCOUNT, "mydocument", "myURI", "mydata") + .expectedIndex = ripple::keylet::did(getAccountIdWithString(kAccount)).key, + .mockedEntity = createDidObject(kAccount, "mydocument", "myURI", "mydata") }, NormalPathTestBundle{ .testName = "DirectoryViaDirRoot", @@ -2710,11 +2710,11 @@ generateTestValuesForNormalPathTest() "sub_index": 2 }} }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::keylet::page(ripple::uint256{kINDEX1}, 2).key, + .expectedIndex = ripple::keylet::page(ripple::uint256{kIndex1}, 2).key, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{ripple::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2727,11 +2727,11 @@ generateTestValuesForNormalPathTest() "sub_index": 2 }} }})JSON", - kACCOUNT + kAccount ), .expectedIndex = ripple::keylet::page(ripple::keylet::ownerDir(account1), 2).key, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{ripple::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2743,12 +2743,12 @@ generateTestValuesForNormalPathTest() "owner": "{}" }} }})JSON", - kACCOUNT + kAccount ), // default sub_index is 0 .expectedIndex = ripple::keylet::page(ripple::keylet::ownerDir(account1), 0).key, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{ripple::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2761,10 +2761,10 @@ generateTestValuesForNormalPathTest() "seq": 1 }} }})JSON", - kACCOUNT + kAccount ), .expectedIndex = ripple::keylet::escrow(account1, 1).key, - .mockedEntity = createEscrowLedgerObject(kACCOUNT, kACCOUNT2) + .mockedEntity = createEscrowLedgerObject(kAccount, kAccount2) }, NormalPathTestBundle{ .testName = "DepositPreauthByAuth", @@ -2776,11 +2776,11 @@ generateTestValuesForNormalPathTest() "authorized": "{}" }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedIndex = ripple::keylet::depositPreauth(account1, account2).key, - .mockedEntity = createDepositPreauthLedgerObjectByAuth(kACCOUNT, kACCOUNT2) + .mockedEntity = createDepositPreauthLedgerObjectByAuth(kAccount, kAccount2) }, NormalPathTestBundle{ .testName = "DepositPreauthByAuthCredentials", @@ -2797,20 +2797,20 @@ generateTestValuesForNormalPathTest() ] }} }})JSON", - kACCOUNT, - kACCOUNT2, - kCREDENTIAL_TYPE + kAccount, + kAccount2, + kCredentialType ), .expectedIndex = ripple::keylet::depositPreauth( account1, credentials::createAuthCredentials(createAuthCredentialArray( - std::vector{kACCOUNT2}, - std::vector{kCREDENTIAL_TYPE} + std::vector{kAccount2}, + std::vector{kCredentialType} )) ) .key, .mockedEntity = createDepositPreauthLedgerObjectByAuthCredentials( - kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE + kAccount, kAccount2, kCredentialType ) }, NormalPathTestBundle{ @@ -2824,22 +2824,22 @@ generateTestValuesForNormalPathTest() "credential_type": "{}" }} }})JSON", - kACCOUNT, - kACCOUNT2, - kCREDENTIAL_TYPE + kAccount, + kAccount2, + kCredentialType ), .expectedIndex = ripple::keylet::credential( account1, account2, ripple::Slice( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::strUnHex(kCREDENTIAL_TYPE)->data(), + ripple::strUnHex(kCredentialType)->data(), // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::strUnHex(kCREDENTIAL_TYPE)->size() + ripple::strUnHex(kCredentialType)->size() ) ) .key, - .mockedEntity = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE) + .mockedEntity = createCredentialObject(kAccount, kAccount2, kCredentialType) }, NormalPathTestBundle{ .testName = "RippleState", @@ -2851,12 +2851,12 @@ generateTestValuesForNormalPathTest() "currency": "USD" }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedIndex = ripple::keylet::line(account1, account2, currency).key, .mockedEntity = createRippleStateLedgerObject( - "USD", kACCOUNT2, 100, kACCOUNT, 10, kACCOUNT2, 20, kINDEX1, 123, 0 + "USD", kAccount2, 100, kAccount, 10, kAccount2, 20, kIndex1, 123, 0 ) }, NormalPathTestBundle{ @@ -2869,10 +2869,10 @@ generateTestValuesForNormalPathTest() "ticket_seq": 2 }} }})JSON", - kACCOUNT + kAccount ), .expectedIndex = ripple::getTicketIndex(account1, 2), - .mockedEntity = createTicketLedgerObject(kACCOUNT, 0) + .mockedEntity = createTicketLedgerObject(kAccount, 0) }, NormalPathTestBundle{ .testName = "Offer", @@ -2884,18 +2884,18 @@ generateTestValuesForNormalPathTest() "seq": 2 }} }})JSON", - kACCOUNT + kAccount ), .expectedIndex = ripple::keylet::offer(account1, 2).key, .mockedEntity = createOfferLedgerObject( - kACCOUNT, + kAccount, 100, 200, "USD", "XRP", - kACCOUNT2, + kAccount2, ripple::toBase58(ripple::xrpAccount()), - kINDEX1 + kIndex1 ) }, NormalPathTestBundle{ @@ -2905,11 +2905,11 @@ generateTestValuesForNormalPathTest() "binary": true, "amm": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = createAmmObject( - kACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2 + kAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAccount2 ) }, NormalPathTestBundle{ @@ -2928,15 +2928,15 @@ generateTestValuesForNormalPathTest() }} }})JSON", "JPY", - kACCOUNT2 + kAccount2 ), .expectedIndex = ripple::keylet::amm( getIssue("XRP", ripple::toBase58(ripple::xrpAccount())), - getIssue("JPY", kACCOUNT2) + getIssue("JPY", kAccount2) ) .key, .mockedEntity = createAmmObject( - kACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2 + kAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAccount2 ) }, NormalPathTestBundle{ @@ -2957,22 +2957,22 @@ generateTestValuesForNormalPathTest() }} }} }})JSON", - kACCOUNT, - kACCOUNT, - kACCOUNT2, - kACCOUNT3 + kAccount, + kAccount, + kAccount2, + kAccount3 ), .expectedIndex = ripple::keylet::bridge( ripple::STXChainBridge( - getAccountIdWithString(kACCOUNT), + getAccountIdWithString(kAccount), ripple::xrpIssue(), - getAccountIdWithString(kACCOUNT2), - getIssue("JPY", kACCOUNT3) + getAccountIdWithString(kAccount2), + getIssue("JPY", kAccount3) ), ripple::STXChainBridge::ChainType::locking ) .key, - .mockedEntity = createBridgeObject(kACCOUNT, kACCOUNT, kACCOUNT2, "JPY", kACCOUNT3) + .mockedEntity = createBridgeObject(kAccount, kAccount, kAccount2, "JPY", kAccount3) }, NormalPathTestBundle{ .testName = "BridgeIssuing", @@ -2992,22 +2992,22 @@ generateTestValuesForNormalPathTest() }} }} }})JSON", - kACCOUNT2, - kACCOUNT, - kACCOUNT2, - kACCOUNT3 + kAccount2, + kAccount, + kAccount2, + kAccount3 ), .expectedIndex = ripple::keylet::bridge( ripple::STXChainBridge( - getAccountIdWithString(kACCOUNT), + getAccountIdWithString(kAccount), ripple::xrpIssue(), - getAccountIdWithString(kACCOUNT2), - getIssue("JPY", kACCOUNT3) + getAccountIdWithString(kAccount2), + getIssue("JPY", kAccount3) ), ripple::STXChainBridge::ChainType::issuing ) .key, - .mockedEntity = createBridgeObject(kACCOUNT, kACCOUNT, kACCOUNT2, "JPY", kACCOUNT3) + .mockedEntity = createBridgeObject(kAccount, kAccount, kAccount2, "JPY", kAccount3) }, NormalPathTestBundle{ .testName = "XChainOwnedClaimId", @@ -3027,22 +3027,22 @@ generateTestValuesForNormalPathTest() "xchain_owned_claim_id": 10 }} }})JSON", - kACCOUNT, - kACCOUNT2, - kACCOUNT3 + kAccount, + kAccount2, + kAccount3 ), .expectedIndex = ripple::keylet::xChainClaimID( ripple::STXChainBridge( - getAccountIdWithString(kACCOUNT), + getAccountIdWithString(kAccount), ripple::xrpIssue(), - getAccountIdWithString(kACCOUNT2), - getIssue("JPY", kACCOUNT3) + getAccountIdWithString(kAccount2), + getIssue("JPY", kAccount3) ), 10 ) .key, .mockedEntity = createChainOwnedClaimIdObject( - kACCOUNT, kACCOUNT, kACCOUNT2, "JPY", kACCOUNT3, kACCOUNT + kAccount, kAccount, kAccount2, "JPY", kAccount3, kAccount ) }, NormalPathTestBundle{ @@ -3063,22 +3063,22 @@ generateTestValuesForNormalPathTest() "xchain_owned_create_account_claim_id": 10 }} }})JSON", - kACCOUNT, - kACCOUNT2, - kACCOUNT3 + kAccount, + kAccount2, + kAccount3 ), .expectedIndex = ripple::keylet::xChainCreateAccountClaimID( ripple::STXChainBridge( - getAccountIdWithString(kACCOUNT), + getAccountIdWithString(kAccount), ripple::xrpIssue(), - getAccountIdWithString(kACCOUNT2), - getIssue("JPY", kACCOUNT3) + getAccountIdWithString(kAccount2), + getIssue("JPY", kAccount3) ), 10 ) .key, .mockedEntity = createChainOwnedClaimIdObject( - kACCOUNT, kACCOUNT, kACCOUNT2, "JPY", kACCOUNT3, kACCOUNT + kAccount, kAccount, kAccount2, "JPY", kAccount3, kAccount ) }, NormalPathTestBundle{ @@ -3091,17 +3091,17 @@ generateTestValuesForNormalPathTest() "oracle_document_id": 1 }} }})JSON", - kACCOUNT + kAccount ), - .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, + .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kAccount), 1).key, .mockedEntity = createOracleObject( - kACCOUNT, + kAccount, "70726F7669646572", 32u, 1234u, ripple::Blob(8, 's'), ripple::Blob(8, 's'), - kRANGE_MAX - 2, + kRangeMax - 2, ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( 2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3 @@ -3118,17 +3118,17 @@ generateTestValuesForNormalPathTest() "oracle_document_id": "1" }} }})JSON", - kACCOUNT + kAccount ), - .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, + .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kAccount), 1).key, .mockedEntity = createOracleObject( - kACCOUNT, + kAccount, "70726F7669646572", 32u, 1234u, ripple::Blob(8, 's'), ripple::Blob(8, 's'), - kRANGE_MAX - 2, + kRangeMax - 2, ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( 2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3 @@ -3142,17 +3142,17 @@ generateTestValuesForNormalPathTest() "binary": true, "oracle": "{}" }})JSON", - ripple::to_string(ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key) + ripple::to_string(ripple::keylet::oracle(getAccountIdWithString(kAccount), 1).key) ), - .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, + .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kAccount), 1).key, .mockedEntity = createOracleObject( - kACCOUNT, + kAccount, "70726F7669646572", 64u, 4321u, ripple::Blob(8, 'a'), ripple::Blob(8, 'a'), - kRANGE_MAX - 4, + kRangeMax - 4, ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( 1e3, ripple::to_currency("USD"), ripple::to_currency("XRP"), 2 @@ -3169,7 +3169,7 @@ generateTestValuesForNormalPathTest() ripple::to_string(ripple::makeMptID(2, account1)) ), .expectedIndex = ripple::keylet::mptIssuance(ripple::makeMptID(2, account1)).key, - .mockedEntity = createMptIssuanceObject(kACCOUNT, 2, "metadata") + .mockedEntity = createMptIssuanceObject(kAccount, 2, "metadata") }, NormalPathTestBundle{ .testName = "MPTokenViaIndex", @@ -3178,10 +3178,10 @@ generateTestValuesForNormalPathTest() "binary": true, "mptoken": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createMpTokenObject(kACCOUNT, ripple::makeMptID(2, account1)) + .expectedIndex = ripple::uint256{kIndex1}, + .mockedEntity = createMpTokenObject(kAccount, ripple::makeMptID(2, account1)) }, NormalPathTestBundle{ .testName = "MPTokenViaObject", @@ -3193,11 +3193,11 @@ generateTestValuesForNormalPathTest() "mpt_issuance_id": "{}" }} }})JSON", - kACCOUNT, + kAccount, ripple::to_string(ripple::makeMptID(2, account1)) ), .expectedIndex = ripple::keylet::mptoken(ripple::makeMptID(2, account1), account1).key, - .mockedEntity = createMpTokenObject(kACCOUNT, ripple::makeMptID(2, account1)) + .mockedEntity = createMpTokenObject(kAccount, ripple::makeMptID(2, account1)) }, NormalPathTestBundle{ .testName = "PermissionedDomainViaString", @@ -3206,11 +3206,11 @@ generateTestValuesForNormalPathTest() "binary": true, "permissioned_domain": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = ripple::uint256(kIndex1), .mockedEntity = createPermissionedDomainObject( - kACCOUNT, kINDEX1, kRANGE_MAX, 0, ripple::uint256{0}, 0 + kAccount, kIndex1, kRangeMax, 0, ripple::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3223,17 +3223,17 @@ generateTestValuesForNormalPathTest() "seq": {} }} }})JSON", - kACCOUNT, - kRANGE_MAX + kAccount, + kRangeMax ), .expectedIndex = ripple::keylet::permissionedDomain( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::parseBase58(kACCOUNT), - kRANGE_MAX + *ripple::parseBase58(kAccount), + kRangeMax ) .key, .mockedEntity = createPermissionedDomainObject( - kACCOUNT, kINDEX1, kRANGE_MAX, 0, ripple::uint256{0}, 0 + kAccount, kIndex1, kRangeMax, 0, ripple::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3243,13 +3243,13 @@ generateTestValuesForNormalPathTest() "binary": true, "vault": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = ripple::uint256(kIndex1), .mockedEntity = createVault( - kACCOUNT, - kACCOUNT, - kRANGE_MAX, + kAccount, + kAccount, + kRangeMax, "XRP", ripple::toBase58(ripple::xrpAccount()), ripple::uint192(0), @@ -3268,17 +3268,16 @@ generateTestValuesForNormalPathTest() "seq": {} }} }})JSON", - kACCOUNT, - kRANGE_MAX + kAccount, + kRangeMax ), .expectedIndex = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::vault(*ripple::parseBase58(kACCOUNT), kRANGE_MAX) - .key, + ripple::keylet::vault(*ripple::parseBase58(kAccount), kRangeMax).key, .mockedEntity = createVault( - kACCOUNT, - kACCOUNT, - kRANGE_MAX, + kAccount, + kAccount, + kRangeMax, "XRP", ripple::toBase58(ripple::xrpAccount()), ripple::uint192(0), @@ -3294,11 +3293,11 @@ generateTestValuesForNormalPathTest() "binary": true, "loan_broker": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = ripple::uint256(kIndex1), .mockedEntity = createLoanBroker( - kACCOUNT, kACCOUNT, kRANGE_MAX, ripple::uint256{kINDEX1}, 1, ripple::uint256{0}, 0 + kAccount, kAccount, kRangeMax, ripple::uint256{kIndex1}, 1, ripple::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3311,17 +3310,17 @@ generateTestValuesForNormalPathTest() "seq": {} }} }})JSON", - kACCOUNT, - kRANGE_MAX + kAccount, + kRangeMax ), .expectedIndex = ripple::keylet::loanbroker( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::parseBase58(kACCOUNT), - kRANGE_MAX + *ripple::parseBase58(kAccount), + kRangeMax ) .key, .mockedEntity = createLoanBroker( - kACCOUNT, kACCOUNT, kRANGE_MAX, ripple::uint256{kINDEX1}, 1, ripple::uint256{0}, 0 + kAccount, kAccount, kRangeMax, ripple::uint256{kIndex1}, 1, ripple::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3331,11 +3330,11 @@ generateTestValuesForNormalPathTest() "binary": true, "loan": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = ripple::uint256(kIndex1), .mockedEntity = createLoan( - kACCOUNT, ripple::uint256{kINDEX1}, 1, 1000, 86400, 100, ripple::uint256{0}, 0 + kAccount, ripple::uint256{kIndex1}, 1, 1000, 86400, 100, ripple::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3348,11 +3347,11 @@ generateTestValuesForNormalPathTest() "loan_seq": 1 }} }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::keylet::loan(ripple::uint256{kINDEX1}, 1).key, + .expectedIndex = ripple::keylet::loan(ripple::uint256{kIndex1}, 1).key, .mockedEntity = createLoan( - kACCOUNT, ripple::uint256{kINDEX1}, 1, 1000, 86400, 100, ripple::uint256{0}, 0 + kAccount, ripple::uint256{kIndex1}, 1, 1000, 86400, 100, ripple::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3362,11 +3361,11 @@ generateTestValuesForNormalPathTest() "binary": true, "delegate": "{}" }})JSON", - kINDEX1 + kIndex1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = ripple::uint256{kIndex1}, .mockedEntity = - createDelegateObject(kACCOUNT, kACCOUNT2, kINDEX1, 0, ripple::uint256{0}, 0) + createDelegateObject(kAccount, kAccount2, kIndex1, 0, ripple::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "DelegateViaObject", @@ -3378,15 +3377,15 @@ generateTestValuesForNormalPathTest() "authorize": "{}" }} }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ), .expectedIndex = ripple::keylet::delegate( - getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2) + getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2) ) .key, .mockedEntity = - createDelegateObject(kACCOUNT, kACCOUNT2, kINDEX1, 0, ripple::uint256{0}, 0) + createDelegateObject(kAccount, kAccount2, kIndex1, 0, ripple::uint256{0}, 0) }, }; } @@ -3395,7 +3394,7 @@ INSTANTIATE_TEST_CASE_P( RPCLedgerEntryGroup2, RPCLedgerEntryNormalPathTest, ValuesIn(generateTestValuesForNormalPathTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); // Test for normal path @@ -3404,11 +3403,11 @@ TEST_P(RPCLedgerEntryNormalPathTest, NormalPath) { auto const testBundle = GetParam(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); - EXPECT_CALL(*backend_, doFetchLedgerObject(testBundle.expectedIndex, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(testBundle.expectedIndex, kRangeMax, _)) .WillRepeatedly(Return(testBundle.mockedEntity.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3417,8 +3416,8 @@ TEST_P(RPCLedgerEntryNormalPathTest, NormalPath) auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); auto const& outputJson = output.result.value(); - EXPECT_EQ(outputJson.at("ledger_hash").as_string(), kLEDGER_HASH); - EXPECT_EQ(outputJson.at("ledger_index").as_uint64(), kRANGE_MAX); + EXPECT_EQ(outputJson.at("ledger_hash").as_string(), kLedgerHash); + EXPECT_EQ(outputJson.at("ledger_index").as_uint64(), kRangeMax); EXPECT_EQ( outputJson.at("node_binary").as_string(), ripple::strHex(testBundle.mockedEntity.getSerializer().peekData()) @@ -3433,7 +3432,7 @@ TEST_P(RPCLedgerEntryNormalPathTest, NormalPath) // this testcase will test the deserialization of ledger entry TEST_F(RPCLedgerEntryTest, BinaryFalse) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -3454,14 +3453,14 @@ TEST_F(RPCLedgerEntryTest, BinaryFalse) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); // return valid ledger entry which can be deserialized auto const ledgerEntry = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 200, 300, kIndex1, 400); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3471,27 +3470,27 @@ TEST_F(RPCLedgerEntryTest, BinaryFalse) R"JSON({{ "payment_channel": "{}" }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); boost::json::object const entry; auto const vault = createVault( - kACCOUNT, - kACCOUNT, - kRANGE_MAX, + kAccount, + kAccount, + kRangeMax, "XRP", ripple::toBase58(ripple::xrpAccount()), ripple::uint192(0), @@ -3502,7 +3501,7 @@ TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) auto const vaultKey = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::vault(*ripple::parseBase58(kACCOUNT), kRANGE_MAX).key; + ripple::keylet::vault(*ripple::parseBase58(kAccount), kRangeMax).key; ripple::STLedgerEntry const sle{ ripple::SerialIter{ @@ -3525,34 +3524,34 @@ TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) "seq": {} }} }})JSON", - kACCOUNT, - kRANGE_MAX + kAccount, + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("node").at("Owner").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("node").at("Sequence").as_int64(), kRANGE_MAX); + EXPECT_EQ(output.result->at("node").at("Owner").as_string(), kAccount); + EXPECT_EQ(output.result->at("node").at("Sequence").as_int64(), kRangeMax); }); } TEST_F(RPCLedgerEntryTest, LoanBroker_BinaryFalse) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); boost::json::object const entry; auto const loanBroker = createLoanBroker( - kACCOUNT, kACCOUNT, kRANGE_MAX, ripple::uint256{kINDEX1}, 1, ripple::uint256{1}, 0 + kAccount, kAccount, kRangeMax, ripple::uint256{kIndex1}, 1, ripple::uint256{1}, 0 ); auto const loanBrokerKey = ripple::keylet::loanbroker( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::parseBase58(kACCOUNT), - kRANGE_MAX + *ripple::parseBase58(kAccount), + kRangeMax ) .key; @@ -3578,39 +3577,39 @@ TEST_F(RPCLedgerEntryTest, LoanBroker_BinaryFalse) "seq": {} }} }})JSON", - kACCOUNT, - kRANGE_MAX + kAccount, + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("node").at("Owner").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("node").at("Sequence").as_int64(), kRANGE_MAX); + EXPECT_EQ(output.result->at("node").at("Owner").as_string(), kAccount); + EXPECT_EQ(output.result->at("node").at("Sequence").as_int64(), kRangeMax); EXPECT_EQ(output.result->at("node").at("LoanSequence").as_int64(), 1); }); } TEST_F(RPCLedgerEntryTest, Loan_BinaryFalse) { - static constexpr auto kLOAN_SEQ = 1; - static constexpr auto kSTART_DATE = 1000; - static constexpr auto kPAYMENT_INTERVAL = 86400; - static constexpr auto kINTEREST_RATE = 100; + static constexpr auto kLoanSeq = 1; + static constexpr auto kStartDate = 1000; + static constexpr auto kPaymentInterval = 86400; + static constexpr auto kInterestRate = 100; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); boost::json::object const entry; auto const loan = createLoan( - kACCOUNT, - ripple::uint256{kINDEX1}, - kLOAN_SEQ, - kSTART_DATE, - kPAYMENT_INTERVAL, - kINTEREST_RATE, + kAccount, + ripple::uint256{kIndex1}, + kLoanSeq, + kStartDate, + kPaymentInterval, + kInterestRate, ripple::uint256{1}, 0 ); @@ -3629,30 +3628,30 @@ TEST_F(RPCLedgerEntryTest, Loan_BinaryFalse) "loan_seq": {} }} }})JSON", - kINDEX1, - kLOAN_SEQ + kIndex1, + kLoanSeq ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("node").at("Borrower").as_string(), kACCOUNT); - EXPECT_EQ(output.result->at("node").at("LoanSequence").as_int64(), kLOAN_SEQ); - EXPECT_EQ(output.result->at("node").at("StartDate").as_int64(), kSTART_DATE); - EXPECT_EQ(output.result->at("node").at("PaymentInterval").as_int64(), kPAYMENT_INTERVAL); + EXPECT_EQ(output.result->at("node").at("Borrower").as_string(), kAccount); + EXPECT_EQ(output.result->at("node").at("LoanSequence").as_int64(), kLoanSeq); + EXPECT_EQ(output.result->at("node").at("StartDate").as_int64(), kStartDate); + EXPECT_EQ(output.result->at("node").at("PaymentInterval").as_int64(), kPaymentInterval); }); } TEST_F(RPCLedgerEntryTest, UnexpectedLedgerType) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); // return valid ledger entry which can be deserialized auto const ledgerEntry = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 200, 300, kIndex1, 400); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3662,7 +3661,7 @@ TEST_F(RPCLedgerEntryTest, UnexpectedLedgerType) R"JSON({{ "check": "{}" }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); @@ -3674,7 +3673,7 @@ TEST_F(RPCLedgerEntryTest, UnexpectedLedgerType) TEST_F(RPCLedgerEntryTest, LedgerNotExistViaIntSequence) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -3685,8 +3684,8 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaIntSequence) "check": "{}", "ledger_index": {} }})JSON", - kINDEX1, - kRANGE_MAX + kIndex1, + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -3699,7 +3698,7 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaIntSequence) TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) { - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -3710,8 +3709,8 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) "check": "{}", "ledger_index": "{}" }})JSON", - kINDEX1, - kRANGE_MAX + kIndex1, + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -3724,7 +3723,7 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerEntryTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillRepeatedly(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -3735,8 +3734,8 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaHash) "check": "{}", "ledger_hash": "{}" }})JSON", - kINDEX1, - kLEDGER_HASH + kIndex1, + kLedgerHash ) ); auto const output = handler.process(req, Context{yield}); @@ -3795,7 +3794,7 @@ TEST(RPCLedgerEntrySpecTest, DeprecatedFields) // Expected Result: same as BinaryFalse TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -3817,13 +3816,13 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) })JSON"; // return valid ledgerinfo - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const ledgerEntry = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 200, 300, kIndex1, 400); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3834,12 +3833,12 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) "index": "{}", "include_deleted": true }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -3847,7 +3846,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) // Expected Result: return the latest object that is not deleted TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -3866,15 +3865,15 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) "index": "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD" } })JSON"; - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + auto const offer = createNftBuyOffer(kNftId, kAccount); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillOnce(Return(uint32_t{kRANGE_MAX})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + .WillOnce(Return(uint32_t{kRangeMax})); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 1, _)) .WillOnce(Return(offer.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; @@ -3884,12 +3883,12 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) "index": "{}", "include_deleted": true }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -3897,13 +3896,13 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) // Expected Result: return entryNotFound error TEST_F(RPCLedgerEntryTest, LedgerEntryNotExist) { - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillOnce(Return(uint32_t{kRANGE_MAX})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + .WillOnce(Return(uint32_t{kRangeMax})); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 1, _)) .WillOnce(Return(std::optional{})); runSpawn([&, this](auto yield) { @@ -3914,7 +3913,7 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotExist) "index": "{}", "include_deleted": true }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); @@ -3929,7 +3928,7 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotExist) // Expected Result: same as BinaryFalse TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -3951,13 +3950,13 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) })JSON"; // return valid ledgerinfo - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const ledgerEntry = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 200, 300, kIndex1, 400); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3968,12 +3967,12 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) "payment_channel": "{}", "include_deleted": false }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -3981,7 +3980,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) // Expected Result: return the latest object that is not deleted (latest object in this test) TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -4011,19 +4010,19 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) })JSON"; // return valid ledgerinfo - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const line1 = createRippleStateLedgerObject( - "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 + "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ); auto const line2 = createRippleStateLedgerObject( - "USD", kACCOUNT, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 + "USD", kAccount, 10, kAccount2, 100, kAccount, 200, kTxnId, 123 ); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillRepeatedly(Return(line1.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 1, _)) .WillRepeatedly(Return(line2.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -4034,12 +4033,12 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) "index": "{}", "include_deleted": true }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -4047,7 +4046,7 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) // Expected Result: return the latest object that is not deleted TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -4066,15 +4065,15 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) "index": "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD" } })JSON"; - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + auto const offer = createNftBuyOffer(kNftId, kAccount); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillOnce(Return(uint32_t{kRANGE_MAX - 4})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 5, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + .WillOnce(Return(uint32_t{kRangeMax - 4})); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 5, _)) .WillOnce(Return(offer.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; @@ -4084,12 +4083,12 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) "index": "{}", "include_deleted": true }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -4097,11 +4096,11 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) // Expected Result: return entryNotFound error TEST_F(RPCLedgerEntryTest, ObjectSeqNotExist) { - auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); + EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -4112,7 +4111,7 @@ TEST_F(RPCLedgerEntryTest, ObjectSeqNotExist) "index": "{}", "include_deleted": true }})JSON", - kINDEX1 + kIndex1 ) ); auto const output = handler.process(req, Context{yield}); @@ -4126,7 +4125,7 @@ TEST_F(RPCLedgerEntryTest, ObjectSeqNotExist) // this testcase will test the if response includes synthetic mpt_issuance_id TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, "validated": true, @@ -4146,16 +4145,16 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) } })JSON"; - auto const mptId = ripple::makeMptID(2, getAccountIdWithString(kACCOUNT)); + auto const mptId = ripple::makeMptID(2, getAccountIdWithString(kAccount)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); // return valid ledger entry which can be deserialized - auto const ledgerEntry = createMptIssuanceObject(kACCOUNT, 2, "metadata"); + auto const ledgerEntry = createMptIssuanceObject(kAccount, 2, "metadata"); EXPECT_CALL( - *backend_, doFetchLedgerObject(ripple::keylet::mptIssuance(mptId).key, kRANGE_MAX, _) + *backend_, doFetchLedgerObject(ripple::keylet::mptIssuance(mptId).key, kRangeMax, _) ) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); @@ -4171,6 +4170,6 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } diff --git a/tests/unit/rpc/handlers/LedgerIndexTests.cpp b/tests/unit/rpc/handlers/LedgerIndexTests.cpp index db61458cf..2e530e5f6 100644 --- a/tests/unit/rpc/handlers/LedgerIndexTests.cpp +++ b/tests/unit/rpc/handlers/LedgerIndexTests.cpp @@ -18,9 +18,9 @@ namespace { -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; } // namespace @@ -32,7 +32,7 @@ using namespace testing; struct RPCLedgerIndexTest : HandlerBaseTestStrict { RPCLedgerIndexTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } }; @@ -51,16 +51,16 @@ TEST_F(RPCLedgerIndexTest, DateStrNotValid) TEST_F(RPCLedgerIndexTest, NoDateGiven) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX, 5); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax, 5); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillOnce(Return(ledgerHeader)); auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; auto const req = json::parse(R"JSON({})JSON"); runSpawn([&](auto yield) { auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("ledger_index").as_uint64(), kRANGE_MAX); - EXPECT_EQ(output.result->at("ledger_hash").as_string(), kLEDGER_HASH); + EXPECT_EQ(output.result->at("ledger_index").as_uint64(), kRangeMax); + EXPECT_EQ(output.result->at("ledger_hash").as_string(), kLedgerHash); EXPECT_TRUE(output.result->as_object().contains("closed")); }); } @@ -70,9 +70,9 @@ TEST_F(RPCLedgerIndexTest, EarlierThanMinLedger) auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; auto const req = json::parse(R"JSON({"date": "2024-06-25T12:23:05Z"})JSON"); auto const ledgerHeader = createLedgerHeaderWithUnixTime( - kLEDGER_HASH, kRANGE_MIN, 1719318190 + kLedgerHash, kRangeMin, 1719318190 ); //"2024-06-25T12:23:10Z" - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MIN, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMin, _)).WillOnce(Return(ledgerHeader)); runSpawn([&](auto yield) { auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -88,9 +88,9 @@ TEST_F(RPCLedgerIndexTest, ChangeTimeZone) auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; auto const req = json::parse(R"JSON({"date": "2024-06-25T12:23:05Z"})JSON"); auto const ledgerHeader = createLedgerHeaderWithUnixTime( - kLEDGER_HASH, kRANGE_MIN, 1719318190 + kLedgerHash, kRangeMin, 1719318190 ); //"2024-06-25T12:23:10Z" - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MIN, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMin, _)).WillOnce(Return(ledgerHeader)); runSpawn([&](auto yield) { auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -117,19 +117,19 @@ public: return std::vector{ {.testName = "LaterThanMaxLedger", .json = R"JSON({"date": "2024-06-25T12:23:55Z"})JSON", - .expectedLedgerIndex = kRANGE_MAX, + .expectedLedgerIndex = kRangeMax, .closeTimeIso = "2024-06-25T12:23:50Z"}, {.testName = "GreaterThanMinLedger", .json = R"JSON({"date": "2024-06-25T12:23:11Z"})JSON", - .expectedLedgerIndex = kRANGE_MIN, + .expectedLedgerIndex = kRangeMin, .closeTimeIso = "2024-06-25T12:23:10Z"}, {.testName = "IsMinLedger", .json = R"JSON({"date": "2024-06-25T12:23:10Z"})JSON", - .expectedLedgerIndex = kRANGE_MIN, + .expectedLedgerIndex = kRangeMin, .closeTimeIso = "2024-06-25T12:23:10Z"}, {.testName = "IsMaxLedger", .json = R"JSON({"date": "2024-06-25T12:23:50Z"})JSON", - .expectedLedgerIndex = kRANGE_MAX, + .expectedLedgerIndex = kRangeMax, .closeTimeIso = "2024-06-25T12:23:50Z"}, {.testName = "IsMidLedger", .json = R"JSON({"date": "2024-06-25T12:23:30Z"})JSON", @@ -147,7 +147,7 @@ INSTANTIATE_TEST_CASE_P( RPCLedgerIndexTestsGroup, LedgerIndexTests, ValuesIn(LedgerIndexTests::generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(LedgerIndexTests, SearchFromLedgerRange) @@ -157,10 +157,10 @@ TEST_P(LedgerIndexTests, SearchFromLedgerRange) // start from 1719318190 , which is the unix time for 2024-06-25T12:23:10Z to // 2024-06-25T12:23:50Z with step 2 - for (uint32_t i = kRANGE_MIN; i <= kRANGE_MAX; i++) { + for (uint32_t i = kRangeMin; i <= kRangeMax; i++) { auto const ledgerHeader = - createLedgerHeaderWithUnixTime(kLEDGER_HASH, i, 1719318190 + (2 * (i - kRANGE_MIN))); - auto const exactNumberOfCalls = i == kRANGE_MIN ? Exactly(3) : Exactly(2); + createLedgerHeaderWithUnixTime(kLedgerHash, i, 1719318190 + (2 * (i - kRangeMin))); + auto const exactNumberOfCalls = i == kRangeMin ? Exactly(3) : Exactly(2); EXPECT_CALL(*backend_, fetchLedgerBySequence(i, _)) .Times(i == testBundle.expectedLedgerIndex ? exactNumberOfCalls : AtMost(1)) .WillRepeatedly(Return(ledgerHeader)); @@ -172,7 +172,7 @@ TEST_P(LedgerIndexTests, SearchFromLedgerRange) auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->at("ledger_index").as_uint64(), testBundle.expectedLedgerIndex); - EXPECT_EQ(output.result->at("ledger_hash").as_string(), kLEDGER_HASH); + EXPECT_EQ(output.result->at("ledger_hash").as_string(), kLedgerHash); EXPECT_EQ(output.result->at("closed").as_string(), testBundle.closeTimeIso); }); } diff --git a/tests/unit/rpc/handlers/LedgerRangeTests.cpp b/tests/unit/rpc/handlers/LedgerRangeTests.cpp index a5d57b001..48569e691 100644 --- a/tests/unit/rpc/handlers/LedgerRangeTests.cpp +++ b/tests/unit/rpc/handlers/LedgerRangeTests.cpp @@ -13,8 +13,8 @@ using namespace testing; namespace { -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; } // namespace @@ -23,29 +23,29 @@ class RPCLedgerRangeTest : public HandlerBaseTest {}; TEST_F(RPCLedgerRangeTest, LedgerRangeMinMaxSame) { runSpawn([this](auto yield) { - backend_->updateRange(kRANGE_MIN); + backend_->updateRange(kRangeMin); auto const handler = AnyHandler{LedgerRangeHandler{backend_}}; auto const req = json::parse("{}"); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); auto const json = output.result.value(); - EXPECT_EQ(json.at("ledger_index_min").as_uint64(), kRANGE_MIN); - EXPECT_EQ(json.at("ledger_index_max").as_uint64(), kRANGE_MIN); + EXPECT_EQ(json.at("ledger_index_min").as_uint64(), kRangeMin); + EXPECT_EQ(json.at("ledger_index_max").as_uint64(), kRangeMin); }); } TEST_F(RPCLedgerRangeTest, LedgerRangeFullySet) { runSpawn([this](auto yield) { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); auto const handler = AnyHandler{LedgerRangeHandler{backend_}}; auto const req = json::parse("{}"); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); auto const json = output.result.value(); - EXPECT_EQ(json.at("ledger_index_min").as_uint64(), kRANGE_MIN); - EXPECT_EQ(json.at("ledger_index_max").as_uint64(), kRANGE_MAX); + EXPECT_EQ(json.at("ledger_index_min").as_uint64(), kRangeMin); + EXPECT_EQ(json.at("ledger_index_max").as_uint64(), kRangeMax); }); } diff --git a/tests/unit/rpc/handlers/LedgerTests.cpp b/tests/unit/rpc/handlers/LedgerTests.cpp index 0a40c7322..8e1d7a5a7 100644 --- a/tests/unit/rpc/handlers/LedgerTests.cpp +++ b/tests/unit/rpc/handlers/LedgerTests.cpp @@ -29,16 +29,16 @@ namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B1"; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B1"; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kRANGE_MIN = 10; -constexpr auto kRANGE_MAX = 30; -constexpr auto kAPI_VERSION = 2; +constexpr auto kRangeMin = 10; +constexpr auto kRangeMax = 30; +constexpr auto kApiVersion = 2; } // namespace @@ -50,7 +50,7 @@ using namespace testing; struct RPCLedgerHandlerTest : HandlerBaseTest { RPCLedgerHandlerTest() { - backend_->setRange(kRANGE_MIN, kRANGE_MAX); + backend_->setRange(kRangeMin, kRangeMax); } protected: @@ -166,7 +166,7 @@ INSTANTIATE_TEST_CASE_P( RPCLedgerGroup1, LedgerParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(LedgerParameterTest, InvalidParams) @@ -186,7 +186,7 @@ TEST_P(LedgerParameterTest, InvalidParams) TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -195,7 +195,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaIntSequence) R"JSON({{ "ledger_index": {} }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -209,7 +209,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaIntSequence) TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -218,7 +218,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) R"JSON({{ "ledger_index": "{}" }})JSON", - kRANGE_MAX + kRangeMax ) ); auto const output = handler.process(req, Context{yield}); @@ -232,7 +232,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -242,7 +242,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaHash) R"JSON({{ "ledger_hash": "{}" }})JSON", - kLEDGER_HASH + kLedgerHash ) ); auto const output = handler.process(req, Context{yield}); @@ -255,7 +255,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaHash) TEST_F(RPCLedgerHandlerTest, Default) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -276,9 +276,9 @@ TEST_F(RPCLedgerHandlerTest, Default) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -287,15 +287,15 @@ TEST_F(RPCLedgerHandlerTest, Default) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } // fields not supported for specific value can be set to its default value TEST_F(RPCLedgerHandlerTest, ConditionallyNotSupportedFieldsDefaultValue) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) .WillRepeatedly(Return(ledgerHeader)); runSpawn([&, this](auto yield) { @@ -314,7 +314,7 @@ TEST_F(RPCLedgerHandlerTest, ConditionallyNotSupportedFieldsDefaultValue) TEST_F(RPCLedgerHandlerTest, QueryViaLedgerIndex) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence(15, _)).WillByDefault(Return(ledgerHeader)); @@ -329,14 +329,14 @@ TEST_F(RPCLedgerHandlerTest, QueryViaLedgerIndex) TEST_F(RPCLedgerHandlerTest, QueryViaLedgerHash) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kINDEX1}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kIndex1}, _)) .WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(fmt::format(R"JSON({{"ledger_hash": "{}" }})JSON", kINDEX1)); + auto const req = json::parse(fmt::format(R"JSON({{"ledger_hash": "{}" }})JSON", kIndex1)); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); @@ -345,7 +345,7 @@ TEST_F(RPCLedgerHandlerTest, QueryViaLedgerHash) TEST_F(RPCLedgerHandlerTest, BinaryTrue) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -356,9 +356,9 @@ TEST_F(RPCLedgerHandlerTest, BinaryTrue) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -369,13 +369,13 @@ TEST_F(RPCLedgerHandlerTest, BinaryTrue) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinary) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -396,20 +396,20 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinary) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 100, 3, kRANGE_MAX) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, 100, 3, kRangeMax) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - t1.ledgerSequence = kRANGE_MAX; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + t1.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{t1, t1})); runSpawn([&, this](auto yield) { @@ -423,13 +423,13 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinaryV2) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -452,18 +452,18 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinaryV2) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillOnce(Return(ledgerHeader)); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 100, 3, kRANGE_MAX) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, 100, 3, kRangeMax) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - t1.ledgerSequence = kRANGE_MAX; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + t1.ledgerSequence = kRangeMax; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillOnce(Return(std::vector{t1, t1})); runSpawn([&, this](auto yield) { @@ -476,15 +476,15 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinaryV2) })JSON" ); auto const output = - handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinary) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -543,20 +543,20 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinary) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 100, 3, kRANGE_MAX) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, 100, 3, kRangeMax) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - t1.ledgerSequence = kRANGE_MAX; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + t1.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{t1})); runSpawn([&, this](auto yield) { @@ -572,13 +572,13 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinary) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinaryV2) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -642,18 +642,18 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinaryV2) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillOnce(Return(ledgerHeader)); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 100, 3, kRANGE_MAX) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, 100, 3, kRangeMax) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - t1.ledgerSequence = kRANGE_MAX; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + t1.ledgerSequence = kRangeMax; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillOnce(Return(std::vector{t1})); runSpawn([&, this](auto yield) { @@ -665,34 +665,33 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinaryV2) "transactions": true })JSON" ); - auto output = handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + auto output = handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(ledgerHeader)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillOnce(Return(ledgerHeader)); - auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX - 1, 10); - EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX - 1, _)) - .WillOnce(Return(ledgerHeader2)); + auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, kRangeMax - 1, 10); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax - 1, _)).WillOnce(Return(ledgerHeader2)); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 100, 3, kRANGE_MAX) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, 100, 3, kRangeMax) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - t1.ledgerSequence = kRANGE_MAX; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + t1.ledgerSequence = kRangeMax; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillOnce(Return(std::vector{t1})); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax - 1, _)) .WillOnce(Return(std::vector{t1})); runSpawn([&, this](auto yield) { @@ -704,7 +703,7 @@ TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) "transactions": true })JSON" ); - auto output = handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + auto output = handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); auto const req2 = json::parse( @@ -715,10 +714,10 @@ TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) "transactions": true, "ledger_index": {} }})JSON", - kRANGE_MAX - 1 + kRangeMax - 1 ) ); - auto output2 = handler.process(req2, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + auto output2 = handler.process(req2, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output2); EXPECT_NE( output.result->at("ledger").at("transactions").as_array()[0].at("close_time_iso"), @@ -729,13 +728,13 @@ TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) TEST_F(RPCLedgerHandlerTest, TransactionsNotExpand) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchAllTransactionHashesInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionHashesInLedger(kRANGE_MAX, _)) - .WillByDefault(Return(std::vector{ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}})); + ON_CALL(*backend_, fetchAllTransactionHashesInLedger(kRangeMax, _)) + .WillByDefault(Return(std::vector{ripple::uint256{kIndex1}, ripple::uint256{kIndex2}})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -748,14 +747,14 @@ TEST_F(RPCLedgerHandlerTest, TransactionsNotExpand) ASSERT_TRUE(output); EXPECT_EQ( output.result->as_object().at("ledger").at("transactions"), - json::parse(fmt::format(R"JSON(["{}", "{}"])JSON", kINDEX1, kINDEX2)) + json::parse(fmt::format(R"JSON(["{}", "{}"])JSON", kIndex1, kIndex2)) ); }); } TEST_F(RPCLedgerHandlerTest, DiffNotBinary) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON([ { "object_id": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B1", @@ -778,27 +777,27 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary) } ])JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); std::vector los; EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); los.push_back( - LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}} + LedgerObject{.key = ripple::uint256{kIndex2}, .blob = Blob{}} ); // NOLINT(modernize-use-emplace) los.push_back( LedgerObject{ - .key = ripple::uint256{kINDEX1}, - .blob = createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) + .key = ripple::uint256{kIndex1}, + .blob = createAccountRootObject(kAccount, ripple::lsfGlobalFreeze, 1, 10, 2, kIndex1, 3) .getSerializer() .peekData() } ); - ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los)); + ON_CALL(*backend_, fetchLedgerDiff(kRangeMax, _)).WillByDefault(Return(los)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -809,13 +808,13 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("ledger").at("diff"), json::parse(kEXPECTED_OUT)); + EXPECT_EQ(output.result->at("ledger").at("diff"), json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, DiffBinary) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON([ { "object_id": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B1", @@ -827,27 +826,27 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary) } ])JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); std::vector los; EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); los.push_back( - LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}} + LedgerObject{.key = ripple::uint256{kIndex2}, .blob = Blob{}} ); // NOLINT(modernize-use-emplace) los.push_back( LedgerObject{ - .key = ripple::uint256{kINDEX1}, - .blob = createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) + .key = ripple::uint256{kIndex1}, + .blob = createAccountRootObject(kAccount, ripple::lsfGlobalFreeze, 1, 10, 2, kIndex1, 3) .getSerializer() .peekData() } ); - ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los)); + ON_CALL(*backend_, fetchLedgerDiff(kRangeMax, _)).WillByDefault(Return(los)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -859,13 +858,13 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("ledger").at("diff"), json::parse(kEXPECTED_OUT)); + EXPECT_EQ(output.result->at("ledger").at("diff"), json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, OwnerFundsEmpty) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -924,20 +923,20 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsEmpty) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); TransactionAndMetadata t1; - t1.transaction = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 100, 3, kRANGE_MAX) + t1.transaction = createPaymentTransactionObject(kAccount, kAccount2, 100, 3, kRangeMax) .getSerializer() .peekData(); t1.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - t1.ledgerSequence = kRANGE_MAX; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + t1.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{t1})); runSpawn([&, this](auto yield) { @@ -954,13 +953,13 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsEmpty) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger": { "account_hash": "0000000000000000000000000000000000000000000000000000000000000000", @@ -1017,41 +1016,41 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) "validated": true })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; auto const accountObject = createAccountRootObject( - kACCOUNT, 0, kRANGE_MAX, 200 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 + kAccount, 0, kRangeMax, 200 /*balance*/, 2 /*owner object*/, kIndex1, kRangeMax - 1, 0 ) .getSerializer() .peekData(); - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kRangeMax, _)) .WillByDefault(Return(accountObject)); // fee object 2*2+3->7 ; balance 200 - 7 -> 193 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRangeMax, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); TransactionAndMetadata tx; - tx.metadata = createMetaDataForCreateOffer(kCURRENCY, kACCOUNT2, 100, 300, 200) + tx.metadata = createMetaDataForCreateOffer(kCurrency, kAccount2, 100, 300, 200) .getSerializer() .peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300, true) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300, true) .getSerializer() .peekData(); tx.date = 123456; - tx.ledgerSequence = kRANGE_MAX; + tx.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{tx})); runSpawn([&, this](auto yield) { @@ -1068,13 +1067,13 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger": { "closed": true, @@ -1092,41 +1091,41 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) "validated": true })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; auto const accountObject = createAccountRootObject( - kACCOUNT, 0, kRANGE_MAX, 200 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 + kAccount, 0, kRangeMax, 200 /*balance*/, 2 /*owner object*/, kIndex1, kRangeMax - 1, 0 ) .getSerializer() .peekData(); - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kRangeMax, _)) .WillByDefault(Return(accountObject)); // fee object 2*2+3->7 ; balance 200 - 7 -> 193 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRangeMax, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); TransactionAndMetadata tx; - tx.metadata = createMetaDataForCreateOffer(kCURRENCY, kACCOUNT2, 100, 300, 200) + tx.metadata = createMetaDataForCreateOffer(kCurrency, kAccount2, 100, 300, 200) .getSerializer() .peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300, true) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300, true) .getSerializer() .peekData(); tx.date = 123456; - tx.ledgerSequence = kRANGE_MAX; + tx.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{tx})); runSpawn([&, this](auto yield) { @@ -1141,29 +1140,29 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) ); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, OwnerFundsIssuerIsSelf) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); // issuer is self TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 300, 200).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 300, 200).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount, 200, 300) .getSerializer() .peekData(); tx.date = 123456; - tx.ledgerSequence = kRANGE_MAX; + tx.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{tx})); runSpawn([&, this](auto yield) { @@ -1188,7 +1187,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsIssuerIsSelf) TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) { - static constexpr auto kEXPECTED_OUT = + static constexpr auto kExpectedOut = R"JSON({ "ledger": { "closed": true, @@ -1206,41 +1205,41 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) "validated": true })JSON"; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; auto const accountObject = createAccountRootObject( - kACCOUNT, 0, kRANGE_MAX, 6 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 + kAccount, 0, kRangeMax, 6 /*balance*/, 2 /*owner object*/, kIndex1, kRangeMax - 1, 0 ) .getSerializer() .peekData(); - ON_CALL(*backend_, doFetchLedgerObject(accountKk, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(accountKk, kRangeMax, _)) .WillByDefault(Return(accountObject)); // fee object 2*2+3->7 ; balance 6 - 7 -> -1 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRangeMax, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); TransactionAndMetadata tx; - tx.metadata = createMetaDataForCreateOffer(kCURRENCY, kACCOUNT2, 100, 300, 200) + tx.metadata = createMetaDataForCreateOffer(kCurrency, kAccount2, 100, 300, 200) .getSerializer() .peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300, true) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300, true) .getSerializer() .peekData(); tx.date = 123456; - tx.ledgerSequence = kRANGE_MAX; + tx.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{tx})); runSpawn([&, this](auto yield) { @@ -1255,44 +1254,44 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) ); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOut)); }); } TEST_F(RPCLedgerHandlerTest, OwnerFundsNotXRP) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); // mock line auto const line = createRippleStateLedgerObject( - kCURRENCY, kACCOUNT2, 50 /*balance*/, kACCOUNT, 10, kACCOUNT2, 20, kINDEX1, 123 + kCurrency, kAccount2, 50 /*balance*/, kAccount, 10, kAccount2, 20, kIndex1, 123 ); auto lineKey = ripple::keylet::line( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::to_currency(std::string(kCURRENCY)) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::to_currency(std::string(kCurrency)) ) .key; - ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRangeMax, _)) .WillByDefault(Return(line.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); TransactionAndMetadata tx; - tx.metadata = createMetaDataForCreateOffer(kCURRENCY, kACCOUNT2, 100, 300, 200, true) + tx.metadata = createMetaDataForCreateOffer(kCurrency, kAccount2, 100, 300, 200, true) .getSerializer() .peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; - tx.ledgerSequence = kRANGE_MAX; + tx.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{tx})); runSpawn([&, this](auto yield) { @@ -1320,47 +1319,47 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotXRP) TEST_F(RPCLedgerHandlerTest, OwnerFundsIgnoreFreezeLine) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillByDefault(Return(ledgerHeader)); // mock line freeze auto const line = createRippleStateLedgerObject( - kCURRENCY, - kACCOUNT2, + kCurrency, + kAccount2, 50 /*balance*/, - kACCOUNT, + kAccount, 10, - kACCOUNT2, + kAccount2, 20, - kINDEX1, + kIndex1, 123, ripple::lsfLowFreeze | ripple::lsfHighFreeze ); auto lineKey = ripple::keylet::line( - getAccountIdWithString(kACCOUNT), - getAccountIdWithString(kACCOUNT2), - ripple::to_currency(std::string(kCURRENCY)) + getAccountIdWithString(kAccount), + getAccountIdWithString(kAccount2), + ripple::to_currency(std::string(kCurrency)) ) .key; - ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRangeMax, _)) .WillByDefault(Return(line.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); TransactionAndMetadata tx; - tx.metadata = createMetaDataForCreateOffer(kCURRENCY, kACCOUNT2, 100, 300, 200, true) + tx.metadata = createMetaDataForCreateOffer(kCurrency, kAccount2, 100, 300, 200, true) .getSerializer() .peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; - tx.ledgerSequence = kRANGE_MAX; + tx.ledgerSequence = kRangeMax; EXPECT_CALL(*backend_, fetchAllTransactionsInLedger).Times(1); - ON_CALL(*backend_, fetchAllTransactionsInLedger(kRANGE_MAX, _)) + ON_CALL(*backend_, fetchAllTransactionsInLedger(kRangeMax, _)) .WillByDefault(Return(std::vector{tx})); runSpawn([&, this](auto yield) { diff --git a/tests/unit/rpc/handlers/MPTHoldersTests.cpp b/tests/unit/rpc/handlers/MPTHoldersTests.cpp index 86bbd9464..6a4ab8250 100644 --- a/tests/unit/rpc/handlers/MPTHoldersTests.cpp +++ b/tests/unit/rpc/handlers/MPTHoldersTests.cpp @@ -28,12 +28,12 @@ using namespace testing; namespace { -constexpr auto kHOLDE_R1_ACCOUNT = "rrnAZCqMahreZrKMcZU3t2DZ6yUndT4ubN"; -constexpr auto kHOLDE_R2_ACCOUNT = "rEiNkzogdHEzUxPfsri5XSMqtXUixf2Yx"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kMPT_ID = "000004C463C52827307480341125DA0577DEFC38405B0E3E"; +constexpr auto kHoldeR1Account = "rrnAZCqMahreZrKMcZU3t2DZ6yUndT4ubN"; +constexpr auto kHoldeR2Account = "rEiNkzogdHEzUxPfsri5XSMqtXUixf2Yx"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kMptId = "000004C463C52827307480341125DA0577DEFC38405B0E3E"; -std::string const kMPT_OUT1 = +std::string const kMptOuT1 = R"JSON({ "account": "rrnAZCqMahreZrKMcZU3t2DZ6yUndT4ubN", "flags": 0, @@ -41,7 +41,7 @@ std::string const kMPT_OUT1 = "mptoken_index": "D137F2E5A5767A06CB7A8F060ADE442A30CFF95028E1AF4B8767E3A56877205A" })JSON"; -std::string const kMPT_OUT2 = +std::string const kMptOuT2 = R"JSON({ "account": "rEiNkzogdHEzUxPfsri5XSMqtXUixf2Yx", "flags": 0, @@ -68,7 +68,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonHexLedgerHash) "mpt_issuance_id": "{}", "ledger_hash": "xxx" }})JSON", - kMPT_ID + kMptId ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -90,7 +90,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonStringLedgerHash) "mpt_issuance_id": "{}", "ledger_hash": 123 }})JSON", - kMPT_ID + kMptId ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -112,7 +112,7 @@ TEST_F(RPCMPTHoldersHandlerTest, InvalidLedgerIndexString) "mpt_issuance_id": "{}", "ledger_index": "notvalidated" }})JSON", - kMPT_ID + kMptId ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -182,7 +182,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerInvalidFormat) "mpt_issuance_id": "{}", "marker": "xxx" }})JSON", - kMPT_ID + kMptId ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -204,7 +204,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerNotString) "mpt_issuance_id": "{}", "marker": 1 }})JSON", - kMPT_ID + kMptId ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -220,7 +220,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); auto const input = json::parse( @@ -229,8 +229,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash) "mpt_issuance_id": "{}", "ledger_hash": "{}" }})JSON", - kMPT_ID, - kLEDGER_HASH + kMptId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -256,7 +256,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex) "mpt_issuance_id": "{}", "ledger_index": "4" }})JSON", - kMPT_ID + kMptId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -280,7 +280,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex) "mpt_issuance_id": "{}", "ledger_index": 4 }})JSON", - kMPT_ID + kMptId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -298,8 +298,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerinfo = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerinfo = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerinfo)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -308,8 +308,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2) "mpt_issuance_id": "{}", "ledger_hash": "{}" }})JSON", - kMPT_ID, - kLEDGER_HASH + kMptId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -334,7 +334,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2) "mpt_issuance_id": "{}", "ledger_index": "31" }})JSON", - kMPT_ID + kMptId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -350,8 +350,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2) // normal case when MPT does not exist TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound) { - auto ledgerinfo = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerinfo = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerinfo)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); @@ -363,8 +363,8 @@ TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound) "mpt_issuance_id": "{}", "ledger_hash": "{}" }})JSON", - kMPT_ID, - kLEDGER_HASH + kMptId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -388,24 +388,24 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters) "mptokens": [{}], "validated": true }})JSON", - kMPT_ID, - kMPT_OUT1 + kMptId, + kMptOuT1 ); - auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ ) ) .Times(1); @@ -415,7 +415,7 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters) R"JSON({{ "mpt_issuance_id": "{}" }})JSON", - kMPT_ID + kMptId ) ); runSpawn([&, this](auto& yield) { @@ -443,23 +443,23 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts) }}], "validated": true }})JSON", - kMPT_ID + kMptId ); - auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID), 0); + auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId), 0); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ ) ) .Times(1); @@ -469,7 +469,7 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts) R"JSON({{ "mpt_issuance_id": "{}" }})JSON", - kMPT_ID + kMptId ) ); runSpawn([&, this](auto& yield) { @@ -491,26 +491,26 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) "mptokens": [{}], "validated": true }})JSON", - kMPT_ID, + kMptId, specificLedger, - kMPT_OUT1 + kMptOuT1 ); - auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, specificLedger); + auto ledgerInfo = createLedgerHeader(kLedgerHash, specificLedger); ON_CALL(*backend_, fetchLedgerBySequence(specificLedger, _)).WillByDefault(Return(ledgerInfo)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, specificLedger, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), + ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(specificLedger), @@ -525,7 +525,7 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) "mpt_issuance_id": "{}", "ledger_index": {} }})JSON", - kMPT_ID, + kMptId, specificLedger ) ); @@ -548,38 +548,38 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) "validated": true, "marker": "{}" }})JSON", - kMPT_ID, - kMPT_OUT2, - ripple::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)) + kMptId, + kMptOuT2, + ripple::strHex(getAccountIdWithString(kHoldeR1Account)) ); - auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHoldeR2Account, ripple::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; - auto const marker = getAccountIdWithString(kHOLDE_R1_ACCOUNT); + auto const marker = getAccountIdWithString(kHoldeR1Account); ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = marker})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_ + ripple::uint192(kMptId), testing::_, testing::Eq(marker), Const(30), testing::_ ) ) .Times(1); - auto const holder1AccountId = ripple::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)); + auto const holder1AccountId = ripple::strHex(getAccountIdWithString(kHoldeR1Account)); auto const input = json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", "marker": "{}" }})JSON", - kMPT_ID, + kMptId, holder1AccountId ) ); @@ -601,19 +601,19 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) "mptokens": [{}, {}], "validated": true }})JSON", - kMPT_ID, - kMPT_OUT1, - kMPT_OUT2 + kMptId, + kMptOuT1, + kMptOuT2 ); - auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); - auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken1 = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); + auto const mptoken2 = createMpTokenObject(kHoldeR2Account, ripple::uint192(kMptId)); std::vector const mpts = { mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData() }; @@ -622,7 +622,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ ) ) .Times(1); @@ -632,7 +632,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) R"JSON({{ "mpt_issuance_id": "{}" }})JSON", - kMPT_ID + kMptId ) ); runSpawn([&, this](auto& yield) { @@ -653,25 +653,25 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) "mptokens": [{}], "validated": true }})JSON", - kMPT_ID, - kMPT_OUT1 + kMptId, + kMptOuT1 ); - auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), - Const(MPTHoldersHandler::kLIMIT_MAX), + ripple::uint192(kMptId), + Const(MPTHoldersHandler::kLimitMax), testing::Eq(std::nullopt), Const(30), testing::_ @@ -685,8 +685,8 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) "mpt_issuance_id": "{}", "limit": {} }})JSON", - kMPT_ID, - MPTHoldersHandler::kLIMIT_MAX + 1 + kMptId, + MPTHoldersHandler::kLimitMax + 1 ) ); runSpawn([&, this](auto& yield) { diff --git a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp index 756983d09..29a9cb67c 100644 --- a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp @@ -28,11 +28,11 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kNFT_ID = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; -constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kNftId = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; +constexpr auto kIndex1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; } // namespace @@ -53,7 +53,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonHexLedgerHash) "nft_id": "{}", "ledger_hash": "xxx" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -75,7 +75,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitNotInt) "nft_id": "{}", "limit": "xxx" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -96,7 +96,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitNegative) "nft_id": "{}", "limit": -1 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -117,7 +117,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitZero) "nft_id": "{}", "limit": 0 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -138,7 +138,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonStringLedgerHash) "nft_id": "{}", "ledger_hash": 123 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -160,7 +160,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, InvalidLedgerIndexString) "nft_id": "{}", "ledger_index": "notvalidated" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -209,7 +209,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -219,8 +219,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -247,7 +247,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex) "nft_id": "{}", "ledger_index": "4" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -265,8 +265,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex) TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -275,8 +275,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash2) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -301,7 +301,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2) "nft_id": "{}", "ledger_index": "31" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -317,8 +317,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2) // error case when nft is not found TEST_F(RPCNFTBuyOffersHandlerTest, NoNFT) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::nullopt)); @@ -329,8 +329,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NoNFT) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -353,7 +353,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MarkerNotString) "nft_id": "{}", "marker": 9 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -377,7 +377,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, InvalidMarker) "nft_id": "{}", "marker": "123invalid" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -395,7 +395,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, InvalidMarker) "nft_id": "{}", "marker": 250 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -409,7 +409,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, InvalidMarker) // normal case when only provide nft_id TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) { - static constexpr auto kCORRECT_OUTPUT = R"JSON({ + static constexpr auto kCorrectOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "validated": true, "offers": [ @@ -428,14 +428,14 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) ] })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNftId}); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -443,7 +443,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) // return two nft buy offers std::vector bbs; - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); + auto const offer = createNftBuyOffer(kNftId, kAccount); bbs.push_back(offer.getSerializer().peekData()); bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -454,7 +454,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) R"JSON({{ "nft_id": "{}" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { @@ -462,14 +462,14 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCorrectOutput), *output.result); }); } // normal case when provided with nft_id and limit TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -477,13 +477,13 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) std::vector indexes; std::vector bbs; auto repetitions = 500; - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto const offer = createNftBuyOffer(kNftId, kAccount); + auto idx = ripple::uint256{kIndex1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -498,7 +498,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) "nft_id": "{}", "limit": 50 }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { @@ -518,7 +518,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) // normal case when provided with nft_id, limit and marker TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -526,14 +526,14 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) std::vector indexes; std::vector bbs; auto repetitions = 500; - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto const offer = createNftBuyOffer(kNftId, kAccount); + auto idx = ripple::uint256{kIndex1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - auto const cursorBuyOffer = createNftBuyOffer(kNFT_ID, kACCOUNT); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + auto const cursorBuyOffer = createNftBuyOffer(kNftId, kAccount); // first is nft offer object auto const cursor = @@ -543,7 +543,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) .WillByDefault(Return(cursorBuyOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNftId}); auto const startHint = 0ul; // offer node is hardcoded to 0ul auto const secondKey = ripple::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) @@ -560,7 +560,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) "marker": "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353", "limit": 50 }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { @@ -582,7 +582,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) // nothing left after reading remaining 50 entries TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimit) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); @@ -590,14 +590,14 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi std::vector indexes; std::vector bbs; auto repetitions = 100; - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto const offer = createNftBuyOffer(kNftId, kAccount); + auto idx = ripple::uint256{kIndex1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - auto const cursorBuyOffer = createNftBuyOffer(kNFT_ID, kACCOUNT); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + auto const cursorBuyOffer = createNftBuyOffer(kNftId, kAccount); // first is nft offer object auto const cursor = @@ -607,7 +607,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi .WillByDefault(Return(cursorBuyOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNftId}); auto const startHint = 0ul; // offer node is hardcoded to 0ul auto const secondKey = ripple::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) @@ -626,7 +626,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi "marker": "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353", "limit": 50 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -646,7 +646,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi "nft_id": "{}", "limit": 49 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -661,7 +661,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi "nft_id": "{}", "limit": 501 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -671,14 +671,14 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTBuyOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTBuyOffersHandler::kLimitMin + 1, ripple::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -687,9 +687,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) // return two nft buy offers std::vector bbs; - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - bbs.reserve(NFTBuyOffersHandler::kLIMIT_MIN + 1); - for (auto i = 0; i < NFTBuyOffersHandler::kLIMIT_MIN + 1; i++) + auto const offer = createNftBuyOffer(kNftId, kAccount); + bbs.reserve(NFTBuyOffersHandler::kLimitMin + 1); + for (auto i = 0; i < NFTBuyOffersHandler::kLimitMin + 1; i++) bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); @@ -700,8 +700,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) "nft_id": "{}", "limit": {} }})JSON", - kNFT_ID, - NFTBuyOffersHandler::kLIMIT_MIN - 1 + kNftId, + NFTBuyOffersHandler::kLimitMin - 1 ) ); runSpawn([&, this](auto yield) { @@ -709,21 +709,21 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("offers").as_array().size(), NFTBuyOffersHandler::kLIMIT_MIN); - EXPECT_EQ(output.result->at("limit").as_uint64(), NFTBuyOffersHandler::kLIMIT_MIN); + EXPECT_EQ(output.result->at("offers").as_array().size(), NFTBuyOffersHandler::kLimitMin); + EXPECT_EQ(output.result->at("limit").as_uint64(), NFTBuyOffersHandler::kLimitMin); }); } TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTBuyOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTBuyOffersHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -732,9 +732,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) // return two nft buy offers std::vector bbs; - auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - bbs.reserve(NFTBuyOffersHandler::kLIMIT_MAX + 1); - for (auto i = 0; i < NFTBuyOffersHandler::kLIMIT_MAX + 1; i++) + auto const offer = createNftBuyOffer(kNftId, kAccount); + bbs.reserve(NFTBuyOffersHandler::kLimitMax + 1); + for (auto i = 0; i < NFTBuyOffersHandler::kLimitMax + 1; i++) bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); @@ -745,8 +745,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) "nft_id": "{}", "limit": {} }})JSON", - kNFT_ID, - NFTBuyOffersHandler::kLIMIT_MAX + 1 + kNftId, + NFTBuyOffersHandler::kLimitMax + 1 ) ); runSpawn([&, this](auto yield) { @@ -754,7 +754,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("offers").as_array().size(), NFTBuyOffersHandler::kLIMIT_MAX); - EXPECT_EQ(output.result->at("limit").as_uint64(), NFTBuyOffersHandler::kLIMIT_MAX); + EXPECT_EQ(output.result->at("offers").as_array().size(), NFTBuyOffersHandler::kLimitMax); + EXPECT_EQ(output.result->at("limit").as_uint64(), NFTBuyOffersHandler::kLimitMax); }); } diff --git a/tests/unit/rpc/handlers/NFTHistoryTests.cpp b/tests/unit/rpc/handlers/NFTHistoryTests.cpp index 003da307a..2a9f679c8 100644 --- a/tests/unit/rpc/handlers/NFTHistoryTests.cpp +++ b/tests/unit/rpc/handlers/NFTHistoryTests.cpp @@ -26,20 +26,20 @@ using namespace testing; namespace { -constexpr auto kMIN_SEQ = 10; -constexpr auto kMAX_SEQ = 30; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kNFT_ID = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; -constexpr auto kAPI_VERSION = 2; +constexpr auto kMinSeq = 10; +constexpr auto kMaxSeq = 30; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kNftId = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; +constexpr auto kApiVersion = 2; } // namespace struct RPCNFTHistoryHandlerTest : HandlerBaseTest { RPCNFTHistoryHandlerTest() { - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); } }; @@ -229,7 +229,7 @@ INSTANTIATE_TEST_CASE_P( RPCNFTHistoryGroup1, NFTHistoryParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(NFTHistoryParameterTest, InvalidParams) @@ -252,21 +252,21 @@ genTransactions(uint32_t seq1, uint32_t seq2) { auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj = createPaymentTransactionObject(kAccount, kAccount2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = seq1; ripple::STObject const metaObj = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + createPaymentTransactionMetaObject(kAccount, kAccount2, 22, 23); trans1.metadata = metaObj.getSerializer().peekData(); trans1.date = 1; transactions.push_back(trans1); auto trans2 = TransactionAndMetadata(); - ripple::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + ripple::STObject const obj2 = createPaymentTransactionObject(kAccount, kAccount2, 1, 1, 32); trans2.transaction = obj.getSerializer().peekData(); trans2.ledgerSequence = seq2; ripple::STObject const metaObj2 = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + createPaymentTransactionMetaObject(kAccount, kAccount2, 22, 23); trans2.metadata = metaObj2.getSerializer().peekData(); trans2.date = 2; transactions.push_back(trans2); @@ -275,7 +275,7 @@ genTransactions(uint32_t seq1, uint32_t seq2) TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -285,7 +285,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) testing::_, testing::_, true, - testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ + 1, 0})), + testing::Optional(testing::Eq(TransactionsCursor{kMinSeq + 1, 0})), testing::_ ) ) @@ -293,7 +293,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -301,16 +301,16 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) "ledger_index_max": {}, "forward": true }})JSON", - kNFT_ID, - kMIN_SEQ + 1, - kMAX_SEQ - 1 + kNftId, + kMinSeq + 1, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -322,7 +322,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1) { - constexpr auto kOUTPUT = R"JSON({ + constexpr auto kOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "ledger_index_min": 11, "ledger_index_max": 29, @@ -417,7 +417,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1) } })JSON"; - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -427,7 +427,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ) @@ -435,7 +435,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -443,20 +443,20 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1) "ledger_index_max": {}, "forward": false }})JSON", - kNFT_ID, - kMIN_SEQ + 1, - kMAX_SEQ - 1 + kNftId, + kMinSeq + 1, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result.value(), boost::json::parse(kOUTPUT)); + EXPECT_EQ(output.result.value(), boost::json::parse(kOutput)); }); } TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2) { - constexpr auto kOUTPUT = R"JSON({ + constexpr auto kOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "ledger_index_min": 11, "ledger_index_max": 29, @@ -555,7 +555,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2) } })JSON"; - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; EXPECT_CALL( @@ -564,19 +564,19 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ) .WillOnce(Return(transCursor)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(2); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -584,21 +584,21 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2) "ledger_index_max": {}, "forward": false }})JSON", - kNFT_ID, - kMIN_SEQ + 1, - kMAX_SEQ - 1 + kNftId, + kMinSeq + 1, + kMaxSeq - 1 ) ); auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(output.result.value(), boost::json::parse(kOUTPUT)); + EXPECT_EQ(output.result.value(), boost::json::parse(kOutput)); }); } TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -608,7 +608,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) testing::_, testing::_, true, - testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ, 0})), + testing::Optional(testing::Eq(TransactionsCursor{kMinSeq, 0})), testing::_ ) ) @@ -616,7 +616,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -624,16 +624,16 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) "ledger_index_max": {}, "forward": true }})JSON", - kNFT_ID, + kNftId, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -645,7 +645,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -655,7 +655,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ) @@ -663,7 +663,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -671,16 +671,16 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) "ledger_index_max": {}, "forward": false }})JSON", - kNFT_ID, + kNftId, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -692,7 +692,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -702,7 +702,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ) @@ -710,7 +710,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -718,16 +718,16 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) "ledger_index_max": {}, "binary": true }})JSON", - kNFT_ID, + kNftId, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -755,7 +755,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; EXPECT_CALL( @@ -764,7 +764,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq, INT32_MAX})), testing::_ ) ) @@ -772,7 +772,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -780,17 +780,17 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) "ledger_index_max": {}, "binary": true }})JSON", - kNFT_ID, + kNftId, -1, -1 ) ); auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") @@ -818,7 +818,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -836,7 +836,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -846,16 +846,16 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) "forward": false, "marker": {{"ledger": 10, "seq": 11}} }})JSON", - kNFT_ID, + kNftId, -1, -1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ(output.result->at("limit").as_uint64(), 2); EXPECT_EQ( output.result->at("marker").as_object(), @@ -868,7 +868,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerIndex) { // adjust the order for forward->false - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -878,33 +878,33 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerIndex) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ) .Times(1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq - 1); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq - 1, _)).WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", "ledger_index": {} }})JSON", - kNFT_ID, - kMAX_SEQ - 1 + kNftId, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMaxSeq - 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); @@ -914,21 +914,21 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerIndex) TEST_F(RPCNFTHistoryHandlerTest, SpecificNonexistLedgerIntIndex) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq - 1, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", "ledger_index": {} }})JSON", - kNFT_ID, - kMAX_SEQ - 1 + kNftId, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -939,21 +939,21 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificNonexistLedgerIntIndex) TEST_F(RPCNFTHistoryHandlerTest, SpecificNonexistLedgerStringIndex) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq - 1, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", "ledger_index": "{}" }})JSON", - kNFT_ID, - kMAX_SEQ - 1 + kNftId, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -964,7 +964,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificNonexistLedgerStringIndex) TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash) { // adjust the order for forward->false - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -974,34 +974,34 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ) .Times(1); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq - 1); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMaxSeq - 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); @@ -1010,7 +1010,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash) TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) { - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -1020,7 +1020,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ) @@ -1028,7 +1028,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1036,16 +1036,16 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) "ledger_index_max": {}, "forward": false }})JSON", - kNFT_ID, - kMIN_SEQ + 2, - kMAX_SEQ - 1 + kNftId, + kMinSeq + 2, + kMaxSeq - 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 2); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 2); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_FALSE(output.result->as_object().contains("marker")); @@ -1054,7 +1054,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) { - auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); + auto const transactions = genTransactions(kMaxSeq - 1, kMinSeq + 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -1064,7 +1064,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 2, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 2, INT32_MAX})), testing::_ ) ) @@ -1072,7 +1072,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1080,16 +1080,16 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) "ledger_index_max": {}, "forward": false }})JSON", - kNFT_ID, - kMIN_SEQ + 1, - kMAX_SEQ - 2 + kNftId, + kMinSeq + 1, + kMaxSeq - 2 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 2); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 2); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); EXPECT_FALSE(output.result->as_object().contains("limit")); EXPECT_EQ( @@ -1101,7 +1101,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) { - auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); + auto const transactions = genTransactions(kMinSeq + 1, kMaxSeq - 1); auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}}; ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); @@ -1111,7 +1111,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) testing::_, testing::_, false, - testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})), + testing::Optional(testing::Eq(TransactionsCursor{kMaxSeq - 1, INT32_MAX})), testing::_ ) ) @@ -1119,7 +1119,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1128,24 +1128,22 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) "forward": false, "limit": {} }})JSON", - kNFT_ID, - kMIN_SEQ + 1, - kMAX_SEQ - 1, - NFTHistoryHandler::kLIMIT_MAX + 1 + kNftId, + kMinSeq + 1, + kMaxSeq - 1, + NFTHistoryHandler::kLimitMax + 1 ) ); - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); - EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); - EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); + EXPECT_EQ(output.result->at("nft_id").as_string(), kNftId); + EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMinSeq + 1); + EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); - EXPECT_EQ( - output.result->as_object().at("limit").as_uint64(), NFTHistoryHandler::kLIMIT_MAX - ); + EXPECT_EQ(output.result->as_object().at("limit").as_uint64(), NFTHistoryHandler::kLimitMax); }); } diff --git a/tests/unit/rpc/handlers/NFTInfoTests.cpp b/tests/unit/rpc/handlers/NFTInfoTests.cpp index 55b0999c0..01b8625d6 100644 --- a/tests/unit/rpc/handlers/NFTInfoTests.cpp +++ b/tests/unit/rpc/handlers/NFTInfoTests.cpp @@ -24,10 +24,10 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kNFT_ID = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; -constexpr auto kNFT_ID2 = "00081388319F12E15BCA13E1B933BF4C99C8E1BBC36BD4910A85D52F00000022"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kNftId = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; +constexpr auto kNftID2 = "00081388319F12E15BCA13E1B933BF4C99C8E1BBC36BD4910A85D52F00000022"; } // namespace @@ -48,7 +48,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonHexLedgerHash) "nft_id": "{}", "ledger_hash": "xxx" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -70,7 +70,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonStringLedgerHash) "nft_id": "{}", "ledger_hash": 123 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -92,7 +92,7 @@ TEST_F(RPCNFTInfoHandlerTest, InvalidLedgerIndexString) "nft_id": "{}", "ledger_index": "notvalidated" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -141,7 +141,7 @@ TEST_F(RPCNFTInfoHandlerTest, NFTIDNotString) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -151,8 +151,8 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -179,7 +179,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerStringIndex) "nft_id": "{}", "ledger_index": "4" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -204,7 +204,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIntIndex) "nft_id": "{}", "ledger_index": 4 }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -222,8 +222,8 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -232,8 +232,8 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -258,7 +258,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2) "nft_id": "{}", "ledger_index": "31" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -274,21 +274,21 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2) // error case nft does not exist TEST_F(RPCNFTInfoHandlerTest, NonExistNFT) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch nft return empty ON_CALL(*backend_, fetchNFT).WillByDefault(Return(std::optional{})); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); auto const input = json::parse( fmt::format( R"JSON({{ "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -304,7 +304,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistNFT) // normal case when only provide nft_id TEST_F(RPCNFTInfoHandlerTest, DefaultParameters) { - static constexpr auto kCURRENT_OUTPUT = R"JSON({ + static constexpr auto kCurrentOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "ledger_index": 30, "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -318,35 +318,35 @@ TEST_F(RPCNFTInfoHandlerTest, DefaultParameters) "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch nft return something - auto const nft = std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq)); + auto const nft = std::make_optional(createNft(kNftId, kAccount, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); auto const input = json::parse( fmt::format( R"JSON({{ "nft_id": "{}" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCurrentOutput), *output.result); }); } // nft is burned -> should not omit uri TEST_F(RPCNFTInfoHandlerTest, BurnedNFT) { - static constexpr auto kCURRENT_OUTPUT = R"JSON({ + static constexpr auto kCurrentOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "ledger_index": 30, "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -360,37 +360,37 @@ TEST_F(RPCNFTInfoHandlerTest, BurnedNFT) "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch nft return something auto const nft = std::make_optional( - createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, ripple::Blob{'u', 'r', 'i'}, true) + createNft(kNftId, kAccount, ledgerHeader.seq, ripple::Blob{'u', 'r', 'i'}, true) ); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); auto const input = json::parse( fmt::format( R"JSON({{ "nft_id": "{}" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCurrentOutput), *output.result); }); } // uri is not available -> should specify an empty string TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI) { - static constexpr auto kCURRENT_OUTPUT = R"JSON({ + static constexpr auto kCurrentOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "ledger_index": 30, "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -404,36 +404,36 @@ TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI) "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch nft return something auto const nft = - std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, ripple::Blob{})); + std::make_optional(createNft(kNftId, kAccount, ledgerHeader.seq, ripple::Blob{})); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); auto const input = json::parse( fmt::format( R"JSON({{ "nft_id": "{}" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCurrentOutput), *output.result); }); } // check taxon field, transfer fee and serial TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet) { - static constexpr auto kCURRENT_OUTPUT = R"JSON({ + static constexpr auto kCurrentOutput = R"JSON({ "nft_id": "00081388319F12E15BCA13E1B933BF4C99C8E1BBC36BD4910A85D52F00000022", "ledger_index": 30, "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", @@ -447,27 +447,27 @@ TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet) "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch nft return something - auto const nft = std::make_optional(createNft(kNFT_ID2, kACCOUNT, ledgerHeader.seq)); + auto const nft = std::make_optional(createNft(kNftID2, kAccount, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID2}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftID2}, 30, _)).Times(1); auto const input = json::parse( fmt::format( R"JSON({{ "nft_id": "{}" }})JSON", - kNFT_ID2 + kNftID2 ) ); runSpawn([&, this](auto yield) { auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCurrentOutput), *output.result); }); } diff --git a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp index 488187965..37a5920d9 100644 --- a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp @@ -28,11 +28,11 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kNFT_ID = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; -constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kNftId = "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004"; +constexpr auto kIndex1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; } // namespace @@ -53,7 +53,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitNotInt) "nft_id": "{}", "limit": "xxx" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -74,7 +74,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitNegative) "nft_id": "{}", "limit": -1 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -95,7 +95,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitZero) "nft_id": "{}", "limit": 0 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -116,7 +116,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonHexLedgerHash) "nft_id": "{}", "ledger_hash": "xxx" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -138,7 +138,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonStringLedgerHash) "nft_id": "{}", "ledger_hash": 123 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -160,7 +160,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, InvalidLedgerIndexString) "nft_id": "{}", "ledger_index": "notvalidated" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{.yield = yield}); @@ -209,7 +209,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -219,8 +219,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -247,7 +247,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex) "nft_id": "{}", "ledger_index": "4" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -265,8 +265,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex) TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -275,8 +275,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash2) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -301,7 +301,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2) "nft_id": "{}", "ledger_index": "31" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -317,8 +317,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2) // error case when nft is not found TEST_F(RPCNFTSellOffersHandlerTest, NoNFT) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::nullopt)); @@ -329,8 +329,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, NoNFT) "nft_id": "{}", "ledger_hash": "{}" }})JSON", - kNFT_ID, - kLEDGER_HASH + kNftId, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -353,7 +353,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, MarkerNotString) "nft_id": "{}", "marker": 9 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -377,7 +377,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, InvalidMarker) "nft_id": "{}", "marker": "123invalid" }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -395,7 +395,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, InvalidMarker) "nft_id": "{}", "marker": 250 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -409,7 +409,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, InvalidMarker) // normal case when only provide nft_id TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) { - static constexpr auto kCORRECT_OUTPUT = R"JSON({ + static constexpr auto kCorrectOutput = R"JSON({ "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004", "validated": true, "offers": [ @@ -428,14 +428,14 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) ] })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNftId}); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -443,7 +443,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) // return two nft sell offers std::vector bbs; - auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); + auto const offer = createNftSellOffer(kNftId, kAccount); bbs.push_back(offer.getSerializer().peekData()); bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -454,7 +454,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) R"JSON({{ "nft_id": "{}" }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { @@ -462,14 +462,14 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(json::parse(kCorrectOutput), *output.result); }); } // normal case when provided with nft_id and limit TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -477,13 +477,13 @@ TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) std::vector indexes; std::vector bbs; auto repetitions = 500; - auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto const offer = createNftSellOffer(kNftId, kAccount); + auto idx = ripple::uint256{kIndex1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -498,7 +498,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) "nft_id": "{}", "limit": 50 }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { @@ -518,7 +518,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) // normal case when provided with nft_id, limit and marker TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -526,14 +526,14 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) std::vector indexes; std::vector bbs; auto repetitions = 500; - auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto const offer = createNftSellOffer(kNftId, kAccount); + auto idx = ripple::uint256{kIndex1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - auto const cursorSellOffer = createNftSellOffer(kNFT_ID, kACCOUNT); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + auto const cursorSellOffer = createNftSellOffer(kNftId, kAccount); // first is nft offer object auto const cursor = @@ -543,7 +543,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) .WillByDefault(Return(cursorSellOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNftId}); auto const startHint = 0ul; // offer node is hardcoded to 0ul auto const secondKey = ripple::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) @@ -560,7 +560,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) "marker": "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353", "limit": 50 }})JSON", - kNFT_ID + kNftId ) ); runSpawn([&, this](auto yield) { @@ -582,7 +582,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) // nothing left after reading remaining 50 entries TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimit) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); @@ -590,14 +590,14 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim std::vector indexes; std::vector bbs; auto repetitions = 100; - auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto const offer = createNftSellOffer(kNftId, kAccount); + auto idx = ripple::uint256{kIndex1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - auto const cursorSellOffer = createNftSellOffer(kNFT_ID, kACCOUNT); + ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + auto const cursorSellOffer = createNftSellOffer(kNftId, kAccount); // first is nft offer object auto const cursor = @@ -607,7 +607,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim .WillByDefault(Return(cursorSellOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNftId}); auto const startHint = 0ul; // offer node is hardcoded to 0ul auto const secondKey = ripple::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) @@ -626,7 +626,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim "marker": "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353", "limit": 50 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -646,7 +646,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim "nft_id": "{}", "limit": 49 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -661,7 +661,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim "nft_id": "{}", "limit": 501 }})JSON", - kNFT_ID + kNftId ) ); auto const output = handler.process(input, Context{yield}); @@ -671,14 +671,14 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTSellOffersHandler::kLimitMin + 1, ripple::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -687,9 +687,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) // return two nft buy offers std::vector bbs; - auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - bbs.reserve(NFTSellOffersHandler::kLIMIT_MIN + 1); - for (auto i = 0; i < NFTSellOffersHandler::kLIMIT_MIN + 1; i++) + auto const offer = createNftSellOffer(kNftId, kAccount); + bbs.reserve(NFTSellOffersHandler::kLimitMin + 1); + for (auto i = 0; i < NFTSellOffersHandler::kLimitMin + 1; i++) bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); @@ -700,8 +700,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) "nft_id": "{}", "limit": {} }})JSON", - kNFT_ID, - NFTSellOffersHandler::kLIMIT_MIN - 1 + kNftId, + NFTSellOffersHandler::kLimitMin - 1 ) ); runSpawn([&, this](auto yield) { @@ -709,21 +709,21 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("offers").as_array().size(), NFTSellOffersHandler::kLIMIT_MIN); - EXPECT_EQ(output.result->at("limit").as_uint64(), NFTSellOffersHandler::kLIMIT_MIN); + EXPECT_EQ(output.result->at("offers").as_array().size(), NFTSellOffersHandler::kLimitMin); + EXPECT_EQ(output.result->at("limit").as_uint64(), NFTSellOffersHandler::kLimitMin); }); } TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTSellOffersHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -732,9 +732,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) // return two nft buy offers std::vector bbs; - auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - bbs.reserve(NFTSellOffersHandler::kLIMIT_MAX + 1); - for (auto i = 0; i < NFTSellOffersHandler::kLIMIT_MAX + 1; i++) + auto const offer = createNftSellOffer(kNftId, kAccount); + bbs.reserve(NFTSellOffersHandler::kLimitMax + 1); + for (auto i = 0; i < NFTSellOffersHandler::kLimitMax + 1; i++) bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); @@ -745,8 +745,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) "nft_id": "{}", "limit": {} }})JSON", - kNFT_ID, - NFTSellOffersHandler::kLIMIT_MAX + 1 + kNftId, + NFTSellOffersHandler::kLimitMax + 1 ) ); runSpawn([&, this](auto yield) { @@ -754,7 +754,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("offers").as_array().size(), NFTSellOffersHandler::kLIMIT_MAX); - EXPECT_EQ(output.result->at("limit").as_uint64(), NFTSellOffersHandler::kLIMIT_MAX); + EXPECT_EQ(output.result->at("offers").as_array().size(), NFTSellOffersHandler::kLimitMax); + EXPECT_EQ(output.result->at("limit").as_uint64(), NFTSellOffersHandler::kLimitMax); }); } diff --git a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp index 520bf7632..ef68bddc5 100644 --- a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp +++ b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp @@ -27,16 +27,16 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "r4X6JLsBfhNK4UnquNkCxhVHKPkvbQff67"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kNFT_ID1 = +constexpr auto kAccount = "r4X6JLsBfhNK4UnquNkCxhVHKPkvbQff67"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kNftID1 = "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F0000099B00000000"; // taxon 0 -constexpr auto kNFT_ID2 = +constexpr auto kNftID2 = "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F16E5DA9C00000001"; // taxon 0 -constexpr auto kNFT_ID3 = +constexpr auto kNftID3 = "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F5B974D9E00000004"; // taxon 1 -std::string const kNFT1_OUT = +std::string const kNfT1Out = R"JSON({ "nft_id": "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F0000099B00000000", "ledger_index": 29, @@ -49,7 +49,7 @@ std::string const kNFT1_OUT = "nft_taxon": 0, "nft_serial": 0 })JSON"; -std::string const kNFT2_OUT = +std::string const kNfT2Out = R"JSON({ "nft_id": "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F16E5DA9C00000001", "ledger_index": 29, @@ -62,7 +62,7 @@ std::string const kNFT2_OUT = "nft_taxon": 0, "nft_serial": 1 })JSON"; -std::string const kNFT3_OUT = +std::string const kNfT3Out = R"JSON({ "nft_id": "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F5B974D9E00000004", "ledger_index": 29, @@ -95,7 +95,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonHexLedgerHash) "issuer": "{}", "ledger_hash": "xxx" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -117,7 +117,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonStringLedgerHash) "issuer": "{}", "ledger_hash": 123 }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -139,7 +139,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, InvalidLedgerIndexString) "issuer": "{}", "ledger_index": "notvalidated" }})JSON", - kACCOUNT + kAccount ) ); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -203,7 +203,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::optional{})); auto const input = json::parse( @@ -212,8 +212,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash) "issuer": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -239,7 +239,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerStringIndex) "issuer": "{}", "ledger_index": "4" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -263,7 +263,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIntIndex) "issuer": "{}", "ledger_index": 4 }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -281,8 +281,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -291,8 +291,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash2) "issuer": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -317,7 +317,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2) "issuer": "{}", "ledger_index": "31" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -333,8 +333,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2) // normal case when issuer does not exist or has no NFTs TEST_F(RPCNFTsByIssuerHandlerTest, AccountNotFound) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); @@ -346,8 +346,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, AccountNotFound) "issuer": "{}", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](boost::asio::yield_context yield) { @@ -371,18 +371,18 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) "nfts": [{}], "validated": true }})JSON", - kACCOUNT, - kNFT1_OUT + kAccount, + kNfT1Out ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; - auto const account = getAccountIdWithString(kACCOUNT); + std::vector const nfts = {createNft(kNftID1, kAccount, 29)}; + auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL( @@ -395,7 +395,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) R"JSON({{ "issuer": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto& yield) { @@ -428,20 +428,20 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) }}], "validated": true }})JSON", - kACCOUNT, + kAccount, specificLedger ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, specificLedger); + auto ledgerHeader = createLedgerHeader(kLedgerHash, specificLedger); ON_CALL(*backend_, fetchLedgerBySequence(specificLedger, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, specificLedger, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, specificLedger)}; - auto const account = getAccountIdWithString(kACCOUNT); + std::vector const nfts = {createNft(kNftID1, kAccount, specificLedger)}; + auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL( @@ -456,7 +456,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) "issuer": "{}", "ledger_index": {} }})JSON", - kACCOUNT, + kAccount, specificLedger ) ); @@ -479,18 +479,18 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) "validated": true, "nft_taxon": 0 }})JSON", - kACCOUNT, - kNFT1_OUT + kAccount, + kNfT1Out ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; - auto const account = getAccountIdWithString(kACCOUNT); + std::vector const nfts = {createNft(kNftID1, kAccount, 29)}; + auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL( @@ -504,7 +504,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) "issuer": "{}", "nft_taxon": 0 }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto& yield) { @@ -526,22 +526,22 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter) "validated": true, "marker": "00080000EC28C2910FD1C454A51598AAB91C8876286B2E7F5B974D9E00000004" }})JSON", - kACCOUNT, - kNFT3_OUT + kAccount, + kNfT3Out ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - std::vector const nfts = {createNft(kNFT_ID3, kACCOUNT, 29)}; - auto const account = getAccountIdWithString(kACCOUNT); + std::vector const nfts = {createNft(kNftID3, kAccount, 29)}; + auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) - .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = ripple::uint256{kNFT_ID3}})); + .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = ripple::uint256{kNftID3}})); EXPECT_CALL( - *backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNFT_ID1}), _) + *backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNftID1}), _) ) .Times(1); @@ -551,8 +551,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter) "issuer": "{}", "marker": "{}" }})JSON", - kACCOUNT, - kNFT_ID1 + kAccount, + kNftID1 ) ); runSpawn([&, this](auto& yield) { @@ -573,24 +573,24 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) "nfts": [{}, {}, {}], "validated": true }})JSON", - kACCOUNT, - kNFT1_OUT, - kNFT2_OUT, - kNFT3_OUT + kAccount, + kNfT1Out, + kNfT2Out, + kNfT3Out ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = { - createNft(kNFT_ID1, kACCOUNT, 29), - createNft(kNFT_ID2, kACCOUNT, 29), - createNft(kNFT_ID3, kACCOUNT, 29) + createNft(kNftID1, kAccount, 29), + createNft(kNftID2, kAccount, 29), + createNft(kNftID3, kAccount, 29) }; - auto const account = getAccountIdWithString(kACCOUNT); + auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL( @@ -603,7 +603,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) R"JSON({{ "issuer": "{}" }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto& yield) { @@ -624,18 +624,18 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) "nfts": [{}], "validated": true }})JSON", - kACCOUNT, - kNFT1_OUT + kAccount, + kNfT1Out ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = ripple::keylet::account(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; - auto const account = getAccountIdWithString(kACCOUNT); + std::vector const nfts = {createNft(kNftID1, kAccount, 29)}; + auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL( @@ -644,7 +644,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) account, Eq(std::nullopt), Const(30), - NFTsByIssuerHandler::kLIMIT_MAX, + NFTsByIssuerHandler::kLimitMax, Eq(std::nullopt), _ ) @@ -657,8 +657,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) "issuer": "{}", "limit": {} }})JSON", - kACCOUNT, - NFTsByIssuerHandler::kLIMIT_MAX + 1 + kAccount, + NFTsByIssuerHandler::kLimitMax + 1 ) ); runSpawn([&, this](auto& yield) { diff --git a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp index c5edf43c7..79b8e3897 100644 --- a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp +++ b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp @@ -27,13 +27,13 @@ using namespace testing; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; -constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; -constexpr auto kTXN_ID = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIssuer = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD"; +constexpr auto kTxnId = "E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879"; } // namespace @@ -149,7 +149,7 @@ INSTANTIATE_TEST_CASE_P( RPCNoRippleCheckGroup1, NoRippleCheckParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(NoRippleCheckParameterTest, InvalidParams) @@ -169,7 +169,7 @@ TEST_P(NoRippleCheckParameterTest, InvalidParams) TEST_F(NoRippleCheckParameterTest, V1ApiTransactionsIsNotBool) { - static constexpr auto kREQ_JSON = R"JSON( + static constexpr auto kReqJson = R"JSON( { "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "role": "gateway", @@ -180,7 +180,7 @@ TEST_F(NoRippleCheckParameterTest, V1ApiTransactionsIsNotBool) EXPECT_CALL(*backend_, fetchLedgerBySequence); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; - auto const req = json::parse(kREQ_JSON); + auto const req = json::parse(kReqJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); @@ -194,23 +194,23 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "role": "gateway", "ledger_hash": "{}" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -220,26 +220,26 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaHash) TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaIntIndex) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "role": "gateway", "ledger_index": {} }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -249,26 +249,26 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaIntIndex) TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaStringIndex) { - constexpr auto kSEQ = 12; + constexpr auto kSeq = 12; EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kInput = json::parse( fmt::format( R"JSON({{ "account": "{}", "role": "gateway", "ledger_index": "{}" }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(kINPUT, Context{yield}); + auto const output = handler.process(kInput, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); @@ -278,8 +278,8 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaStringIndex) TEST_F(RPCNoRippleCheckTest, AccountNotExist) { - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty @@ -292,8 +292,8 @@ TEST_F(RPCNoRippleCheckTest, AccountNotExist) "ledger_hash": "{}", "role": "gateway" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -308,8 +308,8 @@ TEST_F(RPCNoRippleCheckTest, AccountNotExist) TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRippleSet) { - static constexpr auto kSEQ = 30; - static constexpr auto kEXPECTED_OUTPUT = + static constexpr auto kSeq = 30; + static constexpr auto kExpectedOutput = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -319,31 +319,31 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount, ripple::lsfDefaultRipple, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData() )); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); std::vector bbs; @@ -360,22 +360,22 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple "ledger_hash": "{}", "role": "user" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRippleUnSet) { - static constexpr auto kSEQ = 30; - static constexpr auto kEXPECTED_OUTPUT = + static constexpr auto kSeq = 30; + static constexpr auto kExpectedOutput = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -386,29 +386,29 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); std::vector bbs; @@ -425,22 +425,22 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp "ledger_hash": "{}", "role": "user" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRippleSet) { - static constexpr auto kSEQ = 30; - static constexpr auto kEXPECTED_OUTPUT = + static constexpr auto kSeq = 30; + static constexpr auto kExpectedOutput = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -451,31 +451,31 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount, ripple::lsfDefaultRipple, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData() )); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); std::vector bbs; @@ -492,22 +492,22 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip "ledger_hash": "{}", "role": "gateway" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoRippleUnset) { - static constexpr auto kSEQ = 30; - static constexpr auto kEXPECTED_OUTPUT = + static constexpr auto kSeq = 30; + static constexpr auto kExpectedOutput = R"JSON({ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 30, @@ -517,29 +517,29 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR "validated": true })JSON"; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, 0 ); std::vector bbs; @@ -556,15 +556,15 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR "ledger_hash": "{}", "role": "gateway" }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } @@ -573,33 +573,33 @@ TEST_F( NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoRippleUnsetHighAccount ) { - static constexpr auto kSEQ = 30; + static constexpr auto kSeq = 30; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT2, 10, kACCOUNT, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount2, 10, kAccount, 20, kTxnId, 123, 0 ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT2, 10, kACCOUNT, 20, kTXN_ID, 123, 0 + "USD", kIssuer, 100, kAccount2, 10, kAccount, 20, kTxnId, 123, 0 ); std::vector bbs; @@ -617,8 +617,8 @@ TEST_F( "role": "gateway", "transactions": true }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -632,33 +632,33 @@ TEST_F( TEST_F(RPCNoRippleCheckTest, NormalPathLimit) { - constexpr auto kSEQ = 30; + constexpr auto kSeq = 30; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount, ripple::lsfDefaultRipple, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData() )); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); std::vector bbs; @@ -676,8 +676,8 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit) "role": "gateway", "limit": 1 }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -690,8 +690,8 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit) TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) { - constexpr auto kSEQ = 30; - constexpr auto kTRANSACTION_SEQ = 123; + constexpr auto kSeq = 30; + constexpr auto kTransactionSeq = 123; auto const expectedOutput = fmt::format( R"JSON({{ "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", @@ -736,40 +736,40 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) ], "validated": true }})JSON", - kTRANSACTION_SEQ, - kTRANSACTION_SEQ + 1, + kTransactionSeq, + kTransactionSeq + 1, ripple::tfClearNoRipple, - kTRANSACTION_SEQ + 2, + kTransactionSeq + 2, ripple::tfClearNoRipple ); - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault( - Return(createAccountRootObject(kACCOUNT, 0, kTRANSACTION_SEQ, 200, 2, kINDEX1, 2) + Return(createAccountRootObject(kAccount, 0, kTransactionSeq, 200, 2, kIndex1, 2) .getSerializer() .peekData()) ); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSeq, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); std::vector bbs; @@ -787,8 +787,8 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) "role": "gateway", "transactions": true }})JSON", - kACCOUNT, - kLEDGER_HASH + kAccount, + kLedgerHash ) ); runSpawn([&, this](auto yield) { @@ -801,35 +801,35 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) { - constexpr auto kSEQ = 30; + constexpr auto kSeq = 30; - auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) + createAccountRootObject(kAccount, ripple::lsfDefaultRipple, 2, 200, 2, kIndex1, 2) .getSerializer() .peekData() )); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NoRippleCheckHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NoRippleCheckHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) + auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple ); std::vector bbs; - bbs.reserve(NoRippleCheckHandler::kLIMIT_MAX + 1); - for (auto i = 0; i < NoRippleCheckHandler::kLIMIT_MAX + 1; i++) { + bbs.reserve(NoRippleCheckHandler::kLimitMax + 1); + for (auto i = 0; i < NoRippleCheckHandler::kLimitMax + 1; i++) { bbs.push_back(line1.getSerializer().peekData()); } @@ -844,9 +844,9 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) "role": "gateway", "limit": {} }})JSON", - kACCOUNT, - kLEDGER_HASH, - NoRippleCheckHandler::kLIMIT_MAX + 1 + kAccount, + kLedgerHash, + NoRippleCheckHandler::kLimitMax + 1 ) ); runSpawn([&, this](auto yield) { @@ -855,7 +855,7 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) ASSERT_TRUE(output); EXPECT_EQ( output.result->as_object().at("problems").as_array().size(), - NoRippleCheckHandler::kLIMIT_MAX + NoRippleCheckHandler::kLimitMax ); }); } diff --git a/tests/unit/rpc/handlers/ServerInfoTests.cpp b/tests/unit/rpc/handlers/ServerInfoTests.cpp index c35e5a4cb..aaa4473df 100644 --- a/tests/unit/rpc/handlers/ServerInfoTests.cpp +++ b/tests/unit/rpc/handlers/ServerInfoTests.cpp @@ -31,8 +31,8 @@ using TestServerInfoHandler = BaseServerInfoHandler; namespace { -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kCLIENT_IP = "1.1.1.1"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kClientIp = "1.1.1.1"; } // namespace @@ -63,7 +63,7 @@ struct RPCServerInfoHandlerTest : HandlerBaseTest, MockLoadBalancerTest, MockCou EXPECT_TRUE(validated.contains("age")); EXPECT_EQ(validated.at("age").as_uint64(), 3u); EXPECT_TRUE(validated.contains("hash")); - EXPECT_EQ(boost::json::value_to(validated.at("hash")), kLEDGER_HASH); + EXPECT_EQ(boost::json::value_to(validated.at("hash")), kLedgerHash); EXPECT_TRUE(validated.contains("seq")); EXPECT_EQ(validated.at("seq").as_uint64(), 30u); EXPECT_TRUE(validated.contains("base_fee_xrp")); @@ -140,7 +140,7 @@ TEST_F(RPCServerInfoHandlerTest, NoLedgerHeaderErrorsOutWithInternal) TEST_F(RPCServerInfoHandlerTest, NoFeesErrorsOutWithInternal) { - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::nullopt)); @@ -169,14 +169,14 @@ TEST_F(RPCServerInfoHandlerTest, DefaultOutputIsPresent) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(feeBlob)); EXPECT_CALL( - *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kCLIENT_IP), false, testing::_) + *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kClientIp), false, testing::_) ) .WillOnce(Return(std::unexpected{rpc::ClioError::EtlInvalidResponse})); @@ -194,7 +194,7 @@ TEST_F(RPCServerInfoHandlerTest, DefaultOutputIsPresent) runSpawn([&](auto yield) { auto const req = json::parse("{}"); - auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); + auto const output = handler.process(req, Context{yield, {}, false, kClientIp}); validateNormalOutput(output); @@ -212,14 +212,14 @@ TEST_F(RPCServerInfoHandlerTest, AmendmentBlockedIsPresentIfSet) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(feeBlob)); EXPECT_CALL( - *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kCLIENT_IP), false, testing::_) + *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kClientIp), false, testing::_) ) .WillOnce(Return(std::unexpected{rpc::ClioError::EtlInvalidResponse})); @@ -237,7 +237,7 @@ TEST_F(RPCServerInfoHandlerTest, AmendmentBlockedIsPresentIfSet) runSpawn([&](auto yield) { auto const req = json::parse("{}"); - auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); + auto const output = handler.process(req, Context{yield, {}, false, kClientIp}); validateNormalOutput(output); @@ -253,14 +253,14 @@ TEST_F(RPCServerInfoHandlerTest, CorruptionDetectedIsPresentIfSet) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(feeBlob)); EXPECT_CALL( - *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kCLIENT_IP), false, testing::_) + *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kClientIp), false, testing::_) ) .WillOnce(Return(std::unexpected{rpc::ClioError::EtlInvalidResponse})); @@ -278,7 +278,7 @@ TEST_F(RPCServerInfoHandlerTest, CorruptionDetectedIsPresentIfSet) runSpawn([&](auto yield) { auto const req = json::parse("{}"); - auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); + auto const output = handler.process(req, Context{yield, {}, false, kClientIp}); validateNormalOutput(output); @@ -293,14 +293,14 @@ TEST_F(RPCServerInfoHandlerTest, CacheReportsEnabledFlagCorrectly) MockLoadBalancer* rawBalancerPtr = mockLoadBalancerPtr_.get(); MockCounters const* rawCountersPtr = mockCountersPtr_.get(); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(2).WillRepeatedly(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2).WillRepeatedly(Return(feeBlob)); EXPECT_CALL( - *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kCLIENT_IP), false, testing::_) + *rawBalancerPtr, forwardToRippled(testing::_, testing::Eq(kClientIp), false, testing::_) ) .Times(2) .WillRepeatedly(Return(std::unexpected{rpc::ClioError::EtlInvalidResponse})); @@ -319,7 +319,7 @@ TEST_F(RPCServerInfoHandlerTest, CacheReportsEnabledFlagCorrectly) runSpawn([&](auto yield) { auto const req = json::parse("{}"); - auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); + auto const output = handler.process(req, Context{yield, {}, false, kClientIp}); validateNormalOutput(output); @@ -333,7 +333,7 @@ TEST_F(RPCServerInfoHandlerTest, CacheReportsEnabledFlagCorrectly) runSpawn([&](auto yield) { auto const req = json::parse("{}"); - auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); + auto const output = handler.process(req, Context{yield, {}, false, kClientIp}); validateNormalOutput(output); @@ -351,7 +351,7 @@ TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet) MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); auto const empty = json::object{}; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -394,7 +394,7 @@ TEST_F(RPCServerInfoHandlerTest, BackendCountersPresentWhenRequestWithParam) MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); auto const empty = json::object{}; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -444,7 +444,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent) MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); auto const empty = json::object{}; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); @@ -498,7 +498,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown) MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); auto const empty = json::object{}; - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old + auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); diff --git a/tests/unit/rpc/handlers/SubscribeTests.cpp b/tests/unit/rpc/handlers/SubscribeTests.cpp index 2e3e78acf..6868d9c47 100644 --- a/tests/unit/rpc/handlers/SubscribeTests.cpp +++ b/tests/unit/rpc/handlers/SubscribeTests.cpp @@ -38,16 +38,16 @@ using std::chrono::milliseconds; namespace { -constexpr auto kMIN_SEQ = 10; -constexpr auto kMAX_SEQ = 30; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kPAYS20_USD_GETS10_XRP_BOOK_DIR = +constexpr auto kMinSeq = 10; +constexpr auto kMaxSeq = 30; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kPayS20UsdGetS10XrpBookDir = "43B83ADC452B85FCBADA6CAEAC5181C255A213630D58FFD455071AFD498D0000"; -constexpr auto kPAYS20_XRP_GETS10_USD_BOOK_DIR = +constexpr auto kPayS20XrpGetS10UsdBookDir = "7B1767D41DBCE79D9585CF9D0262A5FEC45E5206FF524F8B55071AFD498D0000"; -constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; +constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; +constexpr auto kIndex2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"; } // namespace @@ -560,7 +560,7 @@ INSTANTIATE_TEST_CASE_P( RPCSubscribe, SubscribeParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(SubscribeParameterTest, InvalidParams) @@ -619,7 +619,7 @@ TEST_F(RPCSubscribeHandlerTest, StreamsWithoutLedger) TEST_F(RPCSubscribeHandlerTest, StreamsLedger) { - static constexpr auto kEXPECTED_OUTPUT = + static constexpr auto kExpectedOutput = R"JSON({ "validated_ledgers": "10-30", "ledger_index": 30, @@ -641,12 +641,12 @@ TEST_F(RPCSubscribeHandlerTest, StreamsLedger) }; EXPECT_CALL(*mockSubscriptionManagerPtr_, subLedger) - .WillOnce(testing::Return(boost::json::parse(kEXPECTED_OUTPUT).as_object())); + .WillOnce(testing::Return(boost::json::parse(kExpectedOutput).as_object())); EXPECT_CALL(*mockSession_, setApiSubversion(0)); auto const output = handler.process(input, Context{yield, session_}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->as_object(), json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(output.result->as_object(), json::parse(kExpectedOutput)); }); } @@ -657,9 +657,9 @@ TEST_F(RPCSubscribeHandlerTest, Accounts) R"JSON({{ "accounts": ["{}", "{}", "{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kACCOUNT2 + kAccount, + kAccount2, + kAccount2 ) ); runSpawn([&, this](auto yield) { @@ -668,10 +668,10 @@ TEST_F(RPCSubscribeHandlerTest, Accounts) }; EXPECT_CALL( - *mockSubscriptionManagerPtr_, subAccount(getAccountIdWithString(kACCOUNT), session_) + *mockSubscriptionManagerPtr_, subAccount(getAccountIdWithString(kAccount), session_) ); EXPECT_CALL( - *mockSubscriptionManagerPtr_, subAccount(getAccountIdWithString(kACCOUNT2), session_) + *mockSubscriptionManagerPtr_, subAccount(getAccountIdWithString(kAccount2), session_) ) .Times(2); EXPECT_CALL(*mockSession_, setApiSubversion(0)); @@ -688,9 +688,9 @@ TEST_F(RPCSubscribeHandlerTest, AccountsProposed) R"JSON({{ "accounts_proposed": ["{}", "{}", "{}"] }})JSON", - kACCOUNT, - kACCOUNT2, - kACCOUNT2 + kAccount, + kAccount2, + kAccount2 ) ); runSpawn([&, this](auto yield) { @@ -700,11 +700,11 @@ TEST_F(RPCSubscribeHandlerTest, AccountsProposed) EXPECT_CALL( *mockSubscriptionManagerPtr_, - subProposedAccount(getAccountIdWithString(kACCOUNT), session_) + subProposedAccount(getAccountIdWithString(kAccount), session_) ); EXPECT_CALL( *mockSubscriptionManagerPtr_, - subProposedAccount(getAccountIdWithString(kACCOUNT2), session_) + subProposedAccount(getAccountIdWithString(kAccount2), session_) ) .Times(2); EXPECT_CALL(*mockSession_, setApiSubversion(0)); @@ -731,7 +731,7 @@ TEST_F(RPCSubscribeHandlerTest, JustBooks) }} ] }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -764,7 +764,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSet) }} ] }})JSON", - kACCOUNT + kAccount ) ); runSpawn([&, this](auto yield) { @@ -798,12 +798,12 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) }} ] }})JSON", - kACCOUNT + kAccount ) ); - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - auto const issuer = getAccountIdWithString(kACCOUNT); + auto const issuer = getAccountIdWithString(kAccount); auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( @@ -827,103 +827,94 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) .value() ); - ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMaxSeq, _)) + .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); - ON_CALL( - *backend_, - doFetchSuccessorKey(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) - ) + ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault(Return(std::nullopt)); - ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); + ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMaxSeq, _)) + .WillByDefault(Return(ripple::uint256{kPayS20XrpGetS10UsdBookDir})); EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(4); // 2 book dirs + 2 issuer global freeze + 2 transferRate + 1 owner root + 1 fee EXPECT_CALL(*backend_, doFetchLedgerObject).Times(8); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); - ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) - ) + auto const indexes = std::vector(10, ripple::uint256{kIndex2}); + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault( - Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) + Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kINDEX1}); - ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _) - ) + auto const indexes2 = std::vector(10, ripple::uint256{kIndex1}); + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20XrpGetS10UsdBookDir}, kMaxSeq, _)) .WillByDefault( - Return(createOwnerDirLedgerObject(indexes2, kINDEX2).getSerializer().peekData()) + Return(createOwnerDirLedgerObject(indexes2, kIndex2).getSerializer().peekData()) ); // offer owner account root ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _ + ripple::keylet::account(getAccountIdWithString(kAccount2)).key, kMaxSeq, _ ) ) .WillByDefault(Return( - createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); // issuer account root ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _ + ripple::keylet::account(getAccountIdWithString(kAccount)).key, kMaxSeq, _ ) ) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMaxSeq, _)) .WillByDefault(Return(feeBlob)); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::xrpCurrency()), ripple::to_string(ripple::to_currency("USD")), toBase58(ripple::xrpAccount()), - kACCOUNT, - kPAYS20_USD_GETS10_XRP_BOOK_DIR + kAccount, + kPayS20UsdGetS10XrpBookDir ); // for reverse // offer owner is USD issuer auto const gets10USDPays20XRPOffer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT, + kAccount, toBase58(ripple::xrpAccount()), - kPAYS20_XRP_GETS10_USD_BOOK_DIR + kPayS20XrpGetS10UsdBookDir ); std::vector const bbs(10, gets10XRPPays20USDOffer.getSerializer().peekData()); - ON_CALL(*backend_, doFetchLedgerObjects(indexes, kMAX_SEQ, _)).WillByDefault(Return(bbs)); + ON_CALL(*backend_, doFetchLedgerObjects(indexes, kMaxSeq, _)).WillByDefault(Return(bbs)); // for reverse std::vector const bbs2(10, gets10USDPays20XRPOffer.getSerializer().peekData()); - ON_CALL(*backend_, doFetchLedgerObjects(indexes2, kMAX_SEQ, _)).WillByDefault(Return(bbs2)); + ON_CALL(*backend_, doFetchLedgerObjects(indexes2, kMaxSeq, _)).WillByDefault(Return(bbs2)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(2); - static auto const kEXPECTED_OFFER = fmt::format( + static auto const kExpectedOffer = fmt::format( R"JSON({{ "Account": "{}", "BookDirectory": "{}", @@ -944,11 +935,11 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) "owner_funds": "193", "quality": "2" }})JSON", - kACCOUNT2, - kPAYS20_USD_GETS10_XRP_BOOK_DIR, - kACCOUNT + kAccount2, + kPayS20UsdGetS10XrpBookDir, + kAccount ); - static auto const kEXPECTED_REVERSED_OFFER = fmt::format( + static auto const kExpectedReversedOffer = fmt::format( R"JSON({{ "Account": "{}", "BookDirectory": "{}", @@ -969,9 +960,9 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) "owner_funds": "10", "quality": "2" }})JSON", - kACCOUNT, - kPAYS20_XRP_GETS10_USD_BOOK_DIR, - kACCOUNT + kAccount, + kPayS20XrpGetS10UsdBookDir, + kAccount ); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{ @@ -985,11 +976,11 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) EXPECT_EQ(output.result->as_object().at("asks").as_array().size(), 10); EXPECT_EQ( output.result->as_object().at("bids").as_array()[0].as_object(), - json::parse(kEXPECTED_OFFER) + json::parse(kExpectedOffer) ); EXPECT_EQ( output.result->as_object().at("asks").as_array()[0].as_object(), - json::parse(kEXPECTED_REVERSED_OFFER) + json::parse(kExpectedReversedOffer) ); }); } @@ -1012,12 +1003,12 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) }} ] }})JSON", - kACCOUNT + kAccount ) ); - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - auto const issuer = getAccountIdWithString(kACCOUNT); + auto const issuer = getAccountIdWithString(kAccount); auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( @@ -1041,102 +1032,93 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) .value() ); - ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMaxSeq, _)) + .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); - ON_CALL( - *backend_, - doFetchSuccessorKey(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) - ) + ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault(Return(std::nullopt)); - ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); + ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMaxSeq, _)) + .WillByDefault(Return(ripple::uint256{kPayS20XrpGetS10UsdBookDir})); EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); - ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) - ) + auto const indexes = std::vector(10, ripple::uint256{kIndex2}); + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault( - Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) + Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kINDEX1}); - ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _) - ) + auto const indexes2 = std::vector(10, ripple::uint256{kIndex1}); + ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20XrpGetS10UsdBookDir}, kMaxSeq, _)) .WillByDefault( - Return(createOwnerDirLedgerObject(indexes2, kINDEX2).getSerializer().peekData()) + Return(createOwnerDirLedgerObject(indexes2, kIndex2).getSerializer().peekData()) ); // offer owner account root ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _ + ripple::keylet::account(getAccountIdWithString(kAccount2)).key, kMaxSeq, _ ) ) .WillByDefault(Return( - createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount2, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); // issuer account root ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _ + ripple::keylet::account(getAccountIdWithString(kAccount)).key, kMaxSeq, _ ) ) .WillByDefault(Return( - createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() )); // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMaxSeq, _)) .WillByDefault(Return(feeBlob)); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( - kACCOUNT2, + kAccount2, 10, 20, ripple::to_string(ripple::xrpCurrency()), ripple::to_string(ripple::to_currency("USD")), toBase58(ripple::xrpAccount()), - kACCOUNT, - kPAYS20_USD_GETS10_XRP_BOOK_DIR + kAccount, + kPayS20UsdGetS10XrpBookDir ); // for reverse // offer owner is USD issuer auto const gets10USDPays20XRPOffer = createOfferLedgerObject( - kACCOUNT, + kAccount, 10, 20, ripple::to_string(ripple::to_currency("USD")), ripple::to_string(ripple::xrpCurrency()), - kACCOUNT, + kAccount, toBase58(ripple::xrpAccount()), - kPAYS20_XRP_GETS10_USD_BOOK_DIR + kPayS20XrpGetS10UsdBookDir ); std::vector const bbs(10, gets10XRPPays20USDOffer.getSerializer().peekData()); - ON_CALL(*backend_, doFetchLedgerObjects(indexes, kMAX_SEQ, _)).WillByDefault(Return(bbs)); + ON_CALL(*backend_, doFetchLedgerObjects(indexes, kMaxSeq, _)).WillByDefault(Return(bbs)); // for reverse std::vector const bbs2(10, gets10USDPays20XRPOffer.getSerializer().peekData()); - ON_CALL(*backend_, doFetchLedgerObjects(indexes2, kMAX_SEQ, _)).WillByDefault(Return(bbs2)); + ON_CALL(*backend_, doFetchLedgerObjects(indexes2, kMaxSeq, _)).WillByDefault(Return(bbs2)); EXPECT_CALL(*backend_, doFetchLedgerObjects); - static auto const kEXPECTED_OFFER = fmt::format( + static auto const kExpectedOffer = fmt::format( R"JSON({{ "Account": "{}", "BookDirectory": "{}", @@ -1157,9 +1139,9 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) "owner_funds": "193", "quality": "2" }})JSON", - kACCOUNT2, - kPAYS20_USD_GETS10_XRP_BOOK_DIR, - kACCOUNT + kAccount2, + kPayS20UsdGetS10XrpBookDir, + kAccount ); runSpawn([&, this](auto yield) { @@ -1173,7 +1155,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) EXPECT_EQ(output.result->as_object().at("offers").as_array().size(), 10); EXPECT_EQ( output.result->as_object().at("offers").as_array()[0].as_object(), - json::parse(kEXPECTED_OFFER) + json::parse(kExpectedOffer) ); }); } @@ -1203,7 +1185,7 @@ TEST_F(RPCSubscribeHandlerTest, APIVersion) TEST(RPCSubscribeHandlerSpecTest, DeprecatedFields) { boost::json::value const json{ - {"streams", kACCOUNT}, + {"streams", kAccount}, {"accounts", {123}}, {"accounts_proposed", "abc"}, {"books", "1"}, diff --git a/tests/unit/rpc/handlers/TransactionEntryTests.cpp b/tests/unit/rpc/handlers/TransactionEntryTests.cpp index 6e841a52c..ce30d8d36 100644 --- a/tests/unit/rpc/handlers/TransactionEntryTests.cpp +++ b/tests/unit/rpc/handlers/TransactionEntryTests.cpp @@ -22,12 +22,12 @@ using namespace testing; namespace { -constexpr auto kINDEX = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; -constexpr auto kTXN_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kAPI_VERSION = 2; +constexpr auto kIndex = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kApiVersion = 2; } // namespace @@ -66,7 +66,7 @@ TEST_F(RPCTransactionEntryHandlerTest, TxHashWrongFormat) TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kINDEX}, _)) + ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kIndex}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -76,8 +76,8 @@ TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerHash) "ledger_hash": "{}", "tx_hash": "{}" }})JSON", - kINDEX, - kTXN_ID + kIndex, + kTxnId ) ); runSpawn([&, this](auto yield) { @@ -103,7 +103,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerIndex) "ledger_index": "4", "tx_hash": "{}" }})JSON", - kTXN_ID + kTxnId ) ); runSpawn([&, this](auto yield) { @@ -118,9 +118,9 @@ TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerIndex) TEST_F(RPCTransactionEntryHandlerTest, TXNotFound) { - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, 30))); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kIndex, 30))); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchTransaction).Times(1); runSpawn([this](auto yield) { @@ -130,7 +130,7 @@ TEST_F(RPCTransactionEntryHandlerTest, TXNotFound) R"JSON({{ "tx_hash": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -145,17 +145,17 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) { TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 10; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, 30))); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kIndex, 30))); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); runSpawn([this](auto yield) { @@ -166,7 +166,7 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) "tx_hash": "{}", "ledger_index": "30" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -179,7 +179,7 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) TEST_F(RPCTransactionEntryHandlerTest, NormalPath) { - static constexpr auto kOUTPUT = R"JSON({ + static constexpr auto kOutput = R"JSON({ "metadata": { "AffectedNodes": [ { @@ -220,18 +220,18 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 30; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(createLedgerHeader(kINDEX, tx.ledgerSequence))); + .WillByDefault(Return(createLedgerHeader(kIndex, tx.ledgerSequence))); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); runSpawn([&, this](auto yield) { @@ -242,19 +242,19 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) "tx_hash": "{}", "ledger_index": {} }})JSON", - kTXN_ID, + kTxnId, tx.ledgerSequence ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kOUTPUT), *output.result); + EXPECT_EQ(json::parse(kOutput), *output.result); }); } TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) { - static constexpr auto kOUTPUT = R"JSON({ + static constexpr auto kOutput = R"JSON({ "meta": { "AffectedNodes": [ { @@ -296,16 +296,16 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 30; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(createLedgerHeader(kINDEX, tx.ledgerSequence))); + .WillOnce(Return(createLedgerHeader(kIndex, tx.ledgerSequence))); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; @@ -315,13 +315,13 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) "tx_hash": "{}", "ledger_index": {} }})JSON", - kTXN_ID, + kTxnId, tx.ledgerSequence ) ); auto const output = - handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kOUTPUT), *output.result); + EXPECT_EQ(json::parse(kOutput), *output.result); }); } diff --git a/tests/unit/rpc/handlers/TxTests.cpp b/tests/unit/rpc/handlers/TxTests.cpp index fae08efc0..4b78f763b 100644 --- a/tests/unit/rpc/handlers/TxTests.cpp +++ b/tests/unit/rpc/handlers/TxTests.cpp @@ -29,17 +29,17 @@ using TestTxHandler = TxHandler; namespace { -constexpr auto kTXN_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; -constexpr auto kNFT_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF"; -constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; -constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000"; -constexpr auto kCTID = "C002807000010002"; // seq 163952 txindex 1 netid 2 -constexpr auto kSEQ_FROM_CTID = 163952; +constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD"; +constexpr auto kNftId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF"; +constexpr auto kNftID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA"; +constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000"; +constexpr auto kCtid = "C002807000010002"; // seq 163952 txindex 1 netid 2 +constexpr auto kSeqFromCtid = 163952; -constexpr auto kDEFAULT_OUT1 = R"JSON({ +constexpr auto kDefaultOuT1 = R"JSON({ "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Fee": "2", "Sequence": 100, @@ -78,7 +78,7 @@ constexpr auto kDEFAULT_OUT1 = R"JSON({ "validated": true })JSON"; -constexpr auto kDEFAULT_OUT2 = R"JSON({ +constexpr auto kDefaultOuT2 = R"JSON({ "hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08", "ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652", "ledger_index": 100, @@ -121,7 +121,7 @@ constexpr auto kDEFAULT_OUT2 = R"JSON({ "close_time_iso": "2000-01-01T00:00:00Z", "validated": true })JSON"; -constexpr auto kINDEX = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; +constexpr auto kIndex = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322"; } // namespace @@ -139,7 +139,7 @@ TEST_F(RPCTxTest, ExcessiveLgrRange) "min_ledger": 1, "max_ledger": 1002 }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -155,14 +155,14 @@ TEST_F(RPCTxTest, InvalidBinaryV1) { TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -177,7 +177,7 @@ TEST_F(RPCTxTest, InvalidBinaryV1) "transaction": "{}", "binary": 12 }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u}); @@ -196,7 +196,7 @@ TEST_F(RPCTxTest, InvalidBinaryV2) "transaction": "{}", "binary": 12 }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u}); @@ -220,7 +220,7 @@ TEST_F(RPCTxTest, InvalidLgrRange) "max_ledger": 1, "min_ledger": 10 }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -234,7 +234,7 @@ TEST_F(RPCTxTest, InvalidLgrRange) TEST_F(RPCTxTest, TxnNotFound) { - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -249,7 +249,7 @@ TEST_F(RPCTxTest, TxnNotFound) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -264,7 +264,7 @@ TEST_F(RPCTxTest, TxnNotFound) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) { backend_->setRange(10, 30); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -281,7 +281,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) "min_ledger": 1, "max_ledger": 1000 }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -297,7 +297,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) { backend_->setRange(1, 1000); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -314,7 +314,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) "min_ledger": 1, "max_ledger": 1000 }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -332,7 +332,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) TEST_F(RPCTxTest, CtidNotFoundSearchAllFalse) { backend_->setRange(1, 1000); - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ_FROM_CTID, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeqFromCtid, _)) .WillOnce(Return(std::vector{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -348,7 +348,7 @@ TEST_F(RPCTxTest, CtidNotFoundSearchAllFalse) "min_ledger": 1, "max_ledger": 1000 }})JSON", - kCTID + kCtid ) ); auto const output = handler.process(req, Context{yield}); @@ -365,15 +365,15 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) { TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -387,13 +387,13 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kDEFAULT_OUT1)); + EXPECT_EQ(*output.result, json::parse(kDefaultOuT1)); }); } @@ -401,13 +401,13 @@ TEST_F(RPCTxTest, PaymentTx_API_v1) { TransactionAndMetadata tx; tx.transaction = - createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 2, 3, 300).getSerializer().peekData(); + createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData(); tx.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -421,7 +421,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v1) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u}); @@ -435,13 +435,13 @@ TEST_F(RPCTxTest, PaymentTx_API_v2) { TransactionAndMetadata tx; tx.transaction = - createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 2, 3, 300).getSerializer().peekData(); + createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData(); tx.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)) .WillOnce(Return(std::nullopt)); @@ -457,7 +457,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v2) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u}); @@ -472,16 +472,16 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) { TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); - auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, tx.ledgerSequence); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + auto const ledgerHeader = createLedgerHeader(kLedgerHash, tx.ledgerSequence); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)) .WillOnce(Return(ledgerHeader)); @@ -497,19 +497,19 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kDEFAULT_OUT2)); + EXPECT_EQ(*output.result, json::parse(kDefaultOuT2)); }); } TEST_F(RPCTxTest, ReturnBinary) { // Note: `inLedger` is API v1 only. See DefaultOutput_* - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000", "tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9", "hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08", @@ -522,14 +522,14 @@ TEST_F(RPCTxTest, ReturnBinary) TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -544,12 +544,12 @@ TEST_F(RPCTxTest, ReturnBinary) "transaction": "{}", "binary": true }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -557,7 +557,7 @@ TEST_F(RPCTxTest, ReturnBinary) TEST_F(RPCTxTest, ReturnBinaryWithCTID) { // Note: `inLedger` is API v1 only. See DefaultOutput_* - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000", "tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9", "hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08", @@ -570,14 +570,14 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -592,19 +592,19 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) "transaction": "{}", "binary": true }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } TEST_F(RPCTxTest, MintNFT) { // Note: `inLedger` is API v1 only. See DefaultOutput_* - static auto const kOUT = fmt::format( + static auto const kOut = fmt::format( R"JSON({{ "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Fee": "50", @@ -657,14 +657,14 @@ TEST_F(RPCTxTest, MintNFT) "inLedger": 100, "validated": true }})JSON", - kNFT_ID, - kNFT_ID + kNftId, + kNftId ); - TransactionAndMetadata tx = createMintNftTxWithMetadata(kACCOUNT, 1, 50, 123, kNFT_ID); + TransactionAndMetadata tx = createMintNftTxWithMetadata(kAccount, 1, 50, 123, kNftId); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -678,23 +678,23 @@ TEST_F(RPCTxTest, MintNFT) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } TEST_F(RPCTxTest, NFTAcceptOffer) { TransactionAndMetadata tx = - createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 50, kNFT_ID, kINDEX); + createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 50, kNftId, kIndex); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -708,23 +708,23 @@ TEST_F(RPCTxTest, NFTAcceptOffer) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("meta").at("nftoken_id").as_string(), kNFT_ID); + EXPECT_EQ(output.result->at("meta").at("nftoken_id").as_string(), kNftId); }); } TEST_F(RPCTxTest, NFTCancelOffer) { - std::vector ids{kNFT_ID, kNFT_ID2}; - TransactionAndMetadata tx = createCancelNftOffersTxWithMetadata(kACCOUNT, 1, 50, ids); + std::vector ids{kNftId, kNftID2}; + TransactionAndMetadata tx = createCancelNftOffersTxWithMetadata(kAccount, 1, 50, ids); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -738,7 +738,7 @@ TEST_F(RPCTxTest, NFTCancelOffer) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); @@ -759,11 +759,11 @@ TEST_F(RPCTxTest, NFTCancelOffer) TEST_F(RPCTxTest, NFTCreateOffer) { TransactionAndMetadata tx = - createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 50, kNFT_ID, 123, kNFT_ID2); + createCreateNftOfferTxWithMetadata(kAccount, 1, 50, kNftId, 123, kNftID2); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -777,12 +777,12 @@ TEST_F(RPCTxTest, NFTCreateOffer) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_TRUE(output.result->at("meta").at("offer_id").as_string() == kNFT_ID2); + EXPECT_TRUE(output.result->at("meta").at("offer_id").as_string() == kNftID2); }); } @@ -797,8 +797,8 @@ TEST_F(RPCTxTest, CTIDAndTransactionBothProvided) "transaction": "{}", "ctid": "{}" }})JSON", - kTXN_ID, - kCTID + kTxnId, + kCtid ) ); auto const output = handler.process(req, Context{yield}); @@ -870,7 +870,7 @@ TEST_F(RPCTxTest, CTIDNotMatch) "command": "tx", "ctid": "{}" }})JSON", - kCTID + kCtid ) ); auto const output = handler.process(req, Context{yield}); @@ -888,7 +888,7 @@ TEST_F(RPCTxTest, CTIDNotMatch) TEST_F(RPCTxTest, ReturnCTIDForTxInput) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Fee": "2", "Sequence": 100, @@ -929,14 +929,14 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -950,18 +950,18 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) { - static constexpr auto kOUT = R"JSON({ + static constexpr auto kOut = R"JSON({ "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Fee": "2", "Sequence": 100, @@ -1001,14 +1001,14 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) TransactionAndMetadata tx; tx.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 100, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData(); tx.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -1022,18 +1022,18 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) "command": "tx", "transaction": "{}" }})JSON", - kTXN_ID + kTxnId ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } TEST_F(RPCTxTest, ViaCTID) { - static auto const kOUT = fmt::format( + static auto const kOut = fmt::format( R"JSON({{ "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Fee": "2", @@ -1072,29 +1072,29 @@ TEST_F(RPCTxTest, ViaCTID) "inLedger": {}, "validated": true }})JSON", - kCTID, - kSEQ_FROM_CTID, - kSEQ_FROM_CTID + kCtid, + kSeqFromCtid, + kSeqFromCtid ); TransactionAndMetadata tx1; tx1.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 1, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 1, 200, 300).getSerializer().peekData(); tx1.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx1.date = 123456; - tx1.ledgerSequence = kSEQ_FROM_CTID; + tx1.ledgerSequence = kSeqFromCtid; TransactionAndMetadata tx2; tx2.transaction = - createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 2, 3, 300).getSerializer().peekData(); + createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData(); tx2.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - tx2.ledgerSequence = kSEQ_FROM_CTID; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + tx2.ledgerSequence = kSeqFromCtid; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ_FROM_CTID, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeqFromCtid, _)) .WillOnce(Return(std::vector{tx1, tx2})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -1109,12 +1109,12 @@ TEST_F(RPCTxTest, ViaCTID) "command": "tx", "ctid": "{}" }})JSON", - kCTID + kCtid ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, json::parse(kOut)); }); } @@ -1122,29 +1122,29 @@ TEST_F(RPCTxTest, ViaLowercaseCTID) { TransactionAndMetadata tx1; tx1.metadata = - createMetaDataForCreateOffer(kCURRENCY, kACCOUNT, 1, 200, 300).getSerializer().peekData(); + createMetaDataForCreateOffer(kCurrency, kAccount, 1, 200, 300).getSerializer().peekData(); tx1.transaction = - createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300) + createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300) .getSerializer() .peekData(); tx1.date = 123456; - tx1.ledgerSequence = kSEQ_FROM_CTID; + tx1.ledgerSequence = kSeqFromCtid; TransactionAndMetadata tx2; tx2.transaction = - createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 2, 3, 300).getSerializer().peekData(); + createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData(); tx2.metadata = - createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 110, 30).getSerializer().peekData(); - tx2.ledgerSequence = kSEQ_FROM_CTID; + createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData(); + tx2.ledgerSequence = kSeqFromCtid; - EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ_FROM_CTID, _)) + EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeqFromCtid, _)) .WillOnce(Return(std::vector{tx1, tx2})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2})); - std::string ctid(kCTID); + std::string ctid(kCtid); std::ranges::transform(ctid, ctid.begin(), ::tolower); runSpawn([&, this](auto yield) { @@ -1160,6 +1160,6 @@ TEST_F(RPCTxTest, ViaLowercaseCTID) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("ctid").as_string(), kCTID); + EXPECT_EQ(output.result->at("ctid").as_string(), kCtid); }); } diff --git a/tests/unit/rpc/handlers/UnsubscribeTests.cpp b/tests/unit/rpc/handlers/UnsubscribeTests.cpp index 281b75079..910156334 100644 --- a/tests/unit/rpc/handlers/UnsubscribeTests.cpp +++ b/tests/unit/rpc/handlers/UnsubscribeTests.cpp @@ -29,8 +29,8 @@ using namespace feed; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; } // namespace @@ -484,7 +484,7 @@ INSTANTIATE_TEST_CASE_P( RPCUnsubscribe, UnsubscribeParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(UnsubscribeParameterTest, InvalidParams) @@ -541,21 +541,21 @@ TEST_F(RPCUnsubscribeTest, Accounts) R"JSON({{ "accounts": ["{}", "{}"] }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ) ); EXPECT_CALL( *mockSubscriptionManagerPtr_, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - unsubAccount(*rpc::accountFromStringStrict(kACCOUNT), _) + unsubAccount(*rpc::accountFromStringStrict(kAccount), _) ) .Times(1); EXPECT_CALL( *mockSubscriptionManagerPtr_, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - unsubAccount(*rpc::accountFromStringStrict(kACCOUNT2), _) + unsubAccount(*rpc::accountFromStringStrict(kAccount2), _) ) .Times(1); @@ -574,21 +574,21 @@ TEST_F(RPCUnsubscribeTest, AccountsProposed) R"JSON({{ "accounts_proposed": ["{}", "{}"] }})JSON", - kACCOUNT, - kACCOUNT2 + kAccount, + kAccount2 ) ); EXPECT_CALL( *mockSubscriptionManagerPtr_, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - unsubProposedAccount(*rpc::accountFromStringStrict(kACCOUNT), _) + unsubProposedAccount(*rpc::accountFromStringStrict(kAccount), _) ) .Times(1); EXPECT_CALL( *mockSubscriptionManagerPtr_, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - unsubProposedAccount(*rpc::accountFromStringStrict(kACCOUNT2), _) + unsubProposedAccount(*rpc::accountFromStringStrict(kAccount2), _) ) .Times(1); @@ -618,7 +618,7 @@ TEST_F(RPCUnsubscribeTest, Books) }} ] }})JSON", - kACCOUNT + kAccount ) ); @@ -654,7 +654,7 @@ TEST_F(RPCUnsubscribeTest, SingleBooks) }} ] }})JSON", - kACCOUNT + kAccount ) ); diff --git a/tests/unit/rpc/handlers/VaultInfoTests.cpp b/tests/unit/rpc/handlers/VaultInfoTests.cpp index 326fe69cb..c8de38425 100644 --- a/tests/unit/rpc/handlers/VaultInfoTests.cpp +++ b/tests/unit/rpc/handlers/VaultInfoTests.cpp @@ -28,21 +28,21 @@ namespace json = boost::json; namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; -constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; -constexpr auto kINDEX1 = "ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890"; -constexpr auto kSEQ = 30; -constexpr auto kASSET_CURRENCY = "XRP"; -constexpr auto kASSET_ISSUER = "rrrrrrrrrrrrrrrrrrrrrhoLvTp"; -constexpr auto kVAULT_ID = "61B03A6F8CEBD3AF9D8F696C3D0A9A9F0493B34BF6B5D93CF0BC009E6BA75303"; -constexpr auto kAPI_VERSION = 2; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"; +constexpr auto kIndex1 = "ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890"; +constexpr auto kSeq = 30; +constexpr auto kAssetCurrency = "XRP"; +constexpr auto kAssetIssuer = "rrrrrrrrrrrrrrrrrrrrrhoLvTp"; +constexpr auto kVaultId = "61B03A6F8CEBD3AF9D8F696C3D0A9A9F0493B34BF6B5D93CF0BC009E6BA75303"; +constexpr auto kApiVersion = 2; } // namespace struct RPCVaultInfoHandlerTest : HandlerBaseTest { RPCVaultInfoHandlerTest() { - backend_->setRange(10, kSEQ); + backend_->setRange(10, kSeq); } protected: @@ -146,8 +146,8 @@ generateTestValuesForParametersTest() "vault_id": "{}", "owner": "{}" }})JSON", - kVAULT_ID, - kACCOUNT + kVaultId, + kAccount ), .expectedError = "malformedRequest", .expectedErrorCode = ClioError::RpcMalformedRequest, @@ -160,7 +160,7 @@ INSTANTIATE_TEST_CASE_P( RPCVaultInfoGroup, VaultInfoParameterTest, ValuesIn(generateTestValuesForParametersTest()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(VaultInfoParameterTest, InvalidParams) @@ -170,7 +170,7 @@ TEST_P(VaultInfoParameterTest, InvalidParams) auto const handler = AnyHandler{VaultInfoHandler{backend_}}; auto const req = json::parse(testBundle.testJson); auto const output = - handler.process(req, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -187,17 +187,17 @@ TEST_P(VaultInfoParameterTest, InvalidParams) TEST_F(RPCVaultInfoHandlerTest, InputHasOwnerButNotFoundResultsInError) { - auto const ledgerHeader = createLedgerHeader(kINDEX1, kSEQ); + auto const ledgerHeader = createLedgerHeader(kIndex1, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Input JSON using vault object - auto static const kINPUT = boost::json::parse( + auto static const kInput = boost::json::parse( fmt::format( R"JSON({{ "owner": "{}", "seq": 3 }})JSON", - kACCOUNT + kAccount ) ); @@ -205,7 +205,7 @@ TEST_F(RPCVaultInfoHandlerTest, InputHasOwnerButNotFoundResultsInError) auto const handler = AnyHandler{VaultInfoHandler{backend_}}; runSpawn([&](auto yield) { auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "entryNotFound"); @@ -216,27 +216,27 @@ TEST_F(RPCVaultInfoHandlerTest, InputHasOwnerButNotFoundResultsInError) TEST_F(RPCVaultInfoHandlerTest, VaultIDFailsVaultDeserializationReturnsEntryNotFound) { - auto const ledgerHeader = createLedgerHeader(kINDEX1, kSEQ); + auto const ledgerHeader = createLedgerHeader(kIndex1, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Mock: vault_id exists, but data is not a valid vault object - ripple::uint256 const vaultKey = ripple::uint256{kVAULT_ID}; - EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKey, kSEQ, _)) + ripple::uint256 const vaultKey = ripple::uint256{kVaultId}; + EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKey, kSeq, _)) .WillOnce(Return(std::nullopt)); // intentionally invalid vault - auto const kINPUT = boost::json::parse( + auto const kInput = boost::json::parse( fmt::format( R"({{ "vault_id": "{}" }})", - kVAULT_ID + kVaultId ) ); auto const handler = AnyHandler{VaultInfoHandler{backend_}}; runSpawn([&](auto yield) { auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -248,7 +248,7 @@ TEST_F(RPCVaultInfoHandlerTest, VaultIDFailsVaultDeserializationReturnsEntryNotF TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) { - auto const ledgerHeader = createLedgerHeader(kINDEX1, kSEQ); + auto const ledgerHeader = createLedgerHeader(kIndex1, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); ripple::uint192 const mptSharesID{123}; @@ -257,38 +257,38 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) uint64_t const ownerNode = 4; auto const vault = createVault( - kACCOUNT, - kACCOUNT2, - kSEQ, - kASSET_CURRENCY, - kASSET_ISSUER, + kAccount, + kAccount2, + kSeq, + kAssetCurrency, + kAssetIssuer, mptSharesID, ownerNode, prevTxId, prevTxSeq ); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVAULT_ID}).key; + auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVaultId}).key; auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSeq, _)) .WillOnce(Return(vault.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(mptIssuance, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(mptIssuance, kSeq, _)) .WillOnce(Return(std::nullopt)); // Missing issuance - auto static const kINPUT = boost::json::parse( + auto static const kInput = boost::json::parse( fmt::format( R"({{ "vault_id": "{}" }})", - kVAULT_ID + kVaultId ) ); auto const handler = AnyHandler{VaultInfoHandler{backend_}}; runSpawn([&](auto yield) { auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "entryNotFound"); @@ -299,7 +299,7 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) { - constexpr auto kEXPECTED_OUTPUT = + constexpr auto kExpectedOutput = R"JSON({ "ledger_index": 30, "validated": true, @@ -337,7 +337,7 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kINDEX1, kSEQ); + auto const ledgerHeader = createLedgerHeader(kIndex1, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Vault params @@ -348,11 +348,11 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) // Mock vault object auto const vault = createVault( - kACCOUNT, - kACCOUNT2, - kSEQ, - kASSET_CURRENCY, - kASSET_ISSUER, + kAccount, + kAccount2, + kSeq, + kAssetCurrency, + kAssetIssuer, mptSharesID, ownerNode, prevTxId, @@ -360,22 +360,22 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) ); // Set up keylet based on vaultID - auto const issuance = createMptIssuanceObject(kACCOUNT, kSEQ, "metadata"); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVAULT_ID}).key; + auto const issuance = createMptIssuanceObject(kAccount, kSeq, "metadata"); + auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVaultId}).key; auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSeq, _)) .WillOnce(Return(vault.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(mptIssuance, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(mptIssuance, kSeq, _)) .WillOnce(Return(issuance.getSerializer().peekData())); // Input JSON using vault_id - auto static const kINPUT = boost::json::parse( + auto static const kInput = boost::json::parse( fmt::format( R"({{ "vault_id": "{}" }})", - kVAULT_ID + kVaultId ) ); @@ -383,15 +383,15 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) auto const handler = AnyHandler{VaultInfoHandler{backend_}}; runSpawn([&](auto yield) { auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) { - constexpr auto kEXPECTED_OUTPUT = + constexpr auto kExpectedOutput = R"JSON({ "ledger_index": 30, "validated": true, @@ -429,7 +429,7 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) } })JSON"; - auto const ledgerHeader = createLedgerHeader(kINDEX1, kSEQ); + auto const ledgerHeader = createLedgerHeader(kIndex1, kSeq); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Vault params @@ -440,42 +440,42 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) // Mock vault object auto const vault = createVault( - kACCOUNT, - kACCOUNT2, - kSEQ, - kASSET_CURRENCY, - kASSET_ISSUER, + kAccount, + kAccount2, + kSeq, + kAssetCurrency, + kAssetIssuer, mptSharesID, ownerNode, prevTxId, prevTxSeq ); - auto const issuance = createMptIssuanceObject(kACCOUNT, kSEQ, "metadata"); + auto const issuance = createMptIssuanceObject(kAccount, kSeq, "metadata"); - auto const accountRoot = createAccountRootObject(kACCOUNT, 0, kSEQ, 200, 2, kINDEX1, 2); - auto const account = getAccountIdWithString(kACCOUNT); + auto const accountRoot = createAccountRootObject(kAccount, 0, kSeq, 200, 2, kIndex1, 2); + auto const account = getAccountIdWithString(kAccount); auto const accountKeylet = ripple::keylet::account(account).key; - auto const vaultKeylet = ripple::keylet::vault(account, kSEQ).key; + auto const vaultKeylet = ripple::keylet::vault(account, kSeq).key; auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; - EXPECT_CALL(*backend_, doFetchLedgerObject(accountKeylet, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(accountKeylet, kSeq, _)) .WillOnce(Return(accountRoot.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSeq, _)) .WillOnce(Return(vault.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(mptIssuance, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(mptIssuance, kSeq, _)) .WillOnce(Return(issuance.getSerializer().peekData())); // Input JSON using vault object - auto static const kINPUT = boost::json::parse( + auto static const kInput = boost::json::parse( fmt::format( R"JSON({{ "owner": "{}", "seq": {}, "ledger_index": 30 }})JSON", - kACCOUNT, - kSEQ + kAccount, + kSeq ) ); @@ -483,8 +483,8 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) auto const handler = AnyHandler{VaultInfoHandler{backend_}}; runSpawn([&](auto yield) { auto const output = - handler.process(kINPUT, Context{.yield = yield, .apiVersion = kAPI_VERSION}); + handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); }); } diff --git a/tests/unit/rpc/handlers/VersionHandlerTests.cpp b/tests/unit/rpc/handlers/VersionHandlerTests.cpp index feb623978..c22dc82d3 100644 --- a/tests/unit/rpc/handlers/VersionHandlerTests.cpp +++ b/tests/unit/rpc/handlers/VersionHandlerTests.cpp @@ -14,9 +14,9 @@ namespace { -constexpr auto kDEFAULT_API_VERSION = 3u; -constexpr auto kMIN_API_VERSION = 2u; -constexpr auto kMAX_API_VERSION = 10u; +constexpr auto kDefaultApiVersion = 3u; +constexpr auto kMinApiVersion = 2u; +constexpr auto kMaxApiVersion = 10u; } // namespace @@ -28,9 +28,9 @@ class RPCVersionHandlerTest : public HandlerBaseTest {}; TEST_F(RPCVersionHandlerTest, Default) { ClioConfigDefinition cfg{ - {"api_version.min", ConfigValue{ConfigType::Integer}.defaultValue(kMIN_API_VERSION)}, - {"api_version.max", ConfigValue{ConfigType::Integer}.defaultValue(kMAX_API_VERSION)}, - {"api_version.default", ConfigValue{ConfigType::Integer}.defaultValue(kDEFAULT_API_VERSION)} + {"api_version.min", ConfigValue{ConfigType::Integer}.defaultValue(kMinApiVersion)}, + {"api_version.max", ConfigValue{ConfigType::Integer}.defaultValue(kMaxApiVersion)}, + {"api_version.default", ConfigValue{ConfigType::Integer}.defaultValue(kDefaultApiVersion)} }; boost::json::value jsonData = boost::json::parse( @@ -40,9 +40,9 @@ TEST_F(RPCVersionHandlerTest, Default) "api_version.max": {}, "api_version.default": {} }})JSON", - kMIN_API_VERSION, - kMAX_API_VERSION, - kDEFAULT_API_VERSION + kMinApiVersion, + kMaxApiVersion, + kDefaultApiVersion ) ); diff --git a/tests/unit/test_data/SslCert.cpp b/tests/unit/test_data/SslCert.cpp index bfeb1b64d..7fa8fc6c7 100644 --- a/tests/unit/test_data/SslCert.cpp +++ b/tests/unit/test_data/SslCert.cpp @@ -9,7 +9,7 @@ namespace tests { std::string_view sslCert() { - static constexpr auto kCERT = R"( + static constexpr auto kCert = R"( -----BEGIN CERTIFICATE----- MIIDrjCCApagAwIBAgIJAOE4Hv/P8CO3MA0GCSqGSIb3DQEBCwUAMDkxEjAQBgNV BAMMCTEyNy4wLjAuMTELMAkGA1UEBhMCVVMxFjAUBgNVBAcMDVNhbiBGcmFuc2lz @@ -33,7 +33,7 @@ LLuOOuPuy2d+HqjKE7z00j28Uf7gZK29bGx1rK+xH6veAr4plKBavBr8WWpAoUG+ PAMNb1i80cMsjK98xXDdr+7Uvy5M4COMwA5XHmMZDEW8Jw== -----END CERTIFICATE----- )"; - return kCERT; + return kCert; } TmpFile @@ -45,7 +45,7 @@ sslCertFile() std::string_view sslKey() { - static constexpr auto kKEY = R"( + static constexpr auto kKey = R"( -----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEAqP3K4WDIhk63zbxSoN8tJqRZD3W0IWFMwCluZchUwsHPxEC4 32sPk58YonynY5nGtTeSGhedSqHD0gFBLcU/su4dSsj+kgGgJwKmiPmoQiTpzEmd @@ -74,7 +74,7 @@ O2R4tGOOkGAX/0/actRXptFk23ucHnSIwcW6HYgDM3tDBP7n3GYdu5CSE1eiR5k7 Zl3fuvbMYcmYKgutFcRj+8NvzRWT2suzGU2x4PiPX+fh5kpvmMdvLA== -----END RSA PRIVATE KEY----- )"; - return kKEY; + return kKey; } TmpFile diff --git a/tests/unit/util/AccountUtilsTests.cpp b/tests/unit/util/AccountUtilsTests.cpp index 2e13e9948..0a7abe982 100644 --- a/tests/unit/util/AccountUtilsTests.cpp +++ b/tests/unit/util/AccountUtilsTests.cpp @@ -6,13 +6,13 @@ #include namespace { -constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; +constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; } // namespace TEST(AccountUtils, parseBase58Wrapper) { EXPECT_FALSE(util::parseBase58Wrapper("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp!")); - EXPECT_TRUE(util::parseBase58Wrapper(kACCOUNT)); + EXPECT_TRUE(util::parseBase58Wrapper(kAccount)); EXPECT_TRUE( util::parseBase58Wrapper( diff --git a/tests/unit/util/BlockingCacheTests.cpp b/tests/unit/util/BlockingCacheTests.cpp index 093f4c751..8f2118cff 100644 --- a/tests/unit/util/BlockingCacheTests.cpp +++ b/tests/unit/util/BlockingCacheTests.cpp @@ -184,7 +184,7 @@ INSTANTIATE_TEST_SUITE_P( .testName = "UpdateFails" } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_F(BlockingCacheTest, InvalidateWhenStateIsNoValue) diff --git a/tests/unit/util/ChannelTests.cpp b/tests/unit/util/ChannelTests.cpp index 14380fcaf..1bd3453e6 100644 --- a/tests/unit/util/ChannelTests.cpp +++ b/tests/unit/util/ChannelTests.cpp @@ -28,13 +28,13 @@ using namespace testing; namespace { -constexpr auto kDEFAULT_THREAD_POOL_SIZE = 4; -constexpr auto kTEST_TIMEOUT = std::chrono::seconds{10}; +constexpr auto kDefaultThreadPoolSize = 4; +constexpr auto kTestTimeout = std::chrono::seconds{10}; -constexpr auto kNUM_SENDERS = 3uz; -constexpr auto kNUM_RECEIVERS = 3uz; -constexpr auto kVALUES_PER_SENDER = 500uz; -constexpr auto kTOTAL_EXPECTED = kNUM_SENDERS * kVALUES_PER_SENDER; +constexpr auto kNumSenders = 3uz; +constexpr auto kNumReceivers = 3uz; +constexpr auto kValuesPerSender = 500uz; +constexpr auto kTotalExpected = kNumSenders * kValuesPerSender; enum class ContextType { IOContext, ThreadPool }; @@ -48,9 +48,9 @@ std::vector generateExpectedValues() { std::vector expectedValues; - expectedValues.reserve(kTOTAL_EXPECTED); - for (auto senderId = 0uz; senderId < kNUM_SENDERS; ++senderId) { - for (auto i = 0uz; i < kVALUES_PER_SENDER; ++i) { + expectedValues.reserve(kTotalExpected); + for (auto senderId = 0uz; senderId < kNumSenders; ++senderId) { + for (auto i = 0uz; i < kValuesPerSender; ++i) { expectedValues.push_back(generateValue(senderId, i)); } } @@ -58,7 +58,7 @@ generateExpectedValues() return expectedValues; } -std::vector const kEXPECTED_VALUES = generateExpectedValues(); +std::vector const kExpectedValues = generateExpectedValues(); std::string contextTypeToString(ContextType type) @@ -77,7 +77,7 @@ public: if (type == ContextType::ThreadPool) { return ContextVariant( - std::in_place_type_t(), kDEFAULT_THREAD_POOL_SIZE + std::in_place_type_t(), kDefaultThreadPoolSize ); } @@ -99,7 +99,7 @@ public: { std::visit( util::OverloadSet{ - [](boost::asio::io_context& context) { context.run_for(kTEST_TIMEOUT); }, + [](boost::asio::io_context& context) { context.run_for(kTestTimeout); }, [](boost::asio::thread_pool& context) { context.join(); }, }, context_ @@ -149,11 +149,11 @@ TEST_P(ChannelSpawnTest, MultipleSendersOneReceiver) { auto localSender = std::move(sender); - for (auto senderId = 0uz; senderId < kNUM_SENDERS; ++senderId) { + for (auto senderId = 0uz; senderId < kNumSenders; ++senderId) { util::spawn( executor, [senderCopy = localSender, senderId](boost::asio::yield_context yield) mutable { - for (auto i = 0uz; i < kVALUES_PER_SENDER; ++i) { + for (auto i = 0uz; i < kValuesPerSender; ++i) { if (not senderCopy.asyncSend(generateValue(senderId, i), yield)) break; } @@ -164,10 +164,10 @@ TEST_P(ChannelSpawnTest, MultipleSendersOneReceiver) context_.run(); - EXPECT_EQ(receivedValues.lock()->size(), kTOTAL_EXPECTED); + EXPECT_EQ(receivedValues.lock()->size(), kTotalExpected); std::ranges::sort(receivedValues.lock().get()); - EXPECT_EQ(receivedValues.lock().get(), kEXPECTED_VALUES); + EXPECT_EQ(receivedValues.lock().get(), kExpectedValues); }); } @@ -176,9 +176,9 @@ TEST_P(ChannelSpawnTest, MultipleSendersMultipleReceivers) context_.withExecutor([this](auto& executor) { auto [sender, receiver] = util::Channel::create(executor, 10); util::Mutex> receivedValues; - std::vector receivers(kNUM_RECEIVERS, receiver); + std::vector receivers(kNumReceivers, receiver); - for (auto receiverId = 0uz; receiverId < kNUM_RECEIVERS; ++receiverId) { + for (auto receiverId = 0uz; receiverId < kNumReceivers; ++receiverId) { util::spawn( executor, [&receiverRef = receivers[receiverId], @@ -195,11 +195,11 @@ TEST_P(ChannelSpawnTest, MultipleSendersMultipleReceivers) { auto localSender = std::move(sender); - for (auto senderId = 0uz; senderId < kNUM_SENDERS; ++senderId) { + for (auto senderId = 0uz; senderId < kNumSenders; ++senderId) { util::spawn( executor, [senderCopy = localSender, senderId](boost::asio::yield_context yield) mutable { - for (auto i = 0uz; i < kVALUES_PER_SENDER; ++i) { + for (auto i = 0uz; i < kValuesPerSender; ++i) { auto const value = generateValue(senderId, i); if (not senderCopy.asyncSend(value, yield)) break; @@ -211,10 +211,10 @@ TEST_P(ChannelSpawnTest, MultipleSendersMultipleReceivers) context_.run(); - EXPECT_EQ(receivedValues.lock()->size(), kTOTAL_EXPECTED); + EXPECT_EQ(receivedValues.lock()->size(), kTotalExpected); std::ranges::sort(receivedValues.lock().get()); - EXPECT_EQ(receivedValues.lock().get(), kEXPECTED_VALUES); + EXPECT_EQ(receivedValues.lock().get(), kExpectedValues); }); } @@ -346,7 +346,7 @@ TEST_P(ChannelCallbackTest, MultipleSendersOneReceiver) util::Mutex> receivedValues; auto receiveNext = [&receiver, &receivedValues](this auto&& self) -> void { - if (receivedValues.lock()->size() >= kTOTAL_EXPECTED) + if (receivedValues.lock()->size() >= kTotalExpected) return; receiver.asyncReceive([&receivedValues, @@ -362,14 +362,14 @@ TEST_P(ChannelCallbackTest, MultipleSendersOneReceiver) { auto localSender = std::move(sender); - for (auto senderId = 0uz; senderId < kNUM_SENDERS; ++senderId) { + for (auto senderId = 0uz; senderId < kNumSenders; ++senderId) { auto senderCopy = localSender; boost::asio::post( executor, [senderCopy = std::move(senderCopy), senderId, &executor]() mutable { auto sendNext = [senderCopy = std::move(senderCopy), senderId, &executor](this auto&& self, std::size_t i) -> void { - if (i >= kVALUES_PER_SENDER) + if (i >= kValuesPerSender) return; senderCopy.asyncSend( @@ -394,10 +394,10 @@ TEST_P(ChannelCallbackTest, MultipleSendersOneReceiver) context_.run(); - EXPECT_EQ(receivedValues.lock()->size(), kTOTAL_EXPECTED); + EXPECT_EQ(receivedValues.lock()->size(), kTotalExpected); std::ranges::sort(receivedValues.lock().get()); - EXPECT_EQ(receivedValues.lock().get(), kEXPECTED_VALUES); + EXPECT_EQ(receivedValues.lock().get(), kExpectedValues); }); } @@ -406,9 +406,9 @@ TEST_P(ChannelCallbackTest, MultipleSendersMultipleReceivers) context_.withExecutor([this](auto& executor) { auto [sender, receiver] = util::Channel::create(executor, 10); util::Mutex> receivedValues; - std::vector receivers(kNUM_RECEIVERS, receiver); + std::vector receivers(kNumReceivers, receiver); - for (auto receiverId = 0uz; receiverId < kNUM_RECEIVERS; ++receiverId) { + for (auto receiverId = 0uz; receiverId < kNumReceivers; ++receiverId) { auto& receiverRef = receivers[receiverId]; auto receiveNext = [&receiverRef, &receivedValues](this auto&& self) -> void { receiverRef.asyncReceive([&receivedValues, @@ -424,14 +424,14 @@ TEST_P(ChannelCallbackTest, MultipleSendersMultipleReceivers) { auto localSender = std::move(sender); - for (auto senderId = 0uz; senderId < kNUM_SENDERS; ++senderId) { + for (auto senderId = 0uz; senderId < kNumSenders; ++senderId) { auto senderCopy = localSender; boost::asio::post( executor, [senderCopy = std::move(senderCopy), senderId, &executor]() mutable { auto sendNext = [senderCopy = std::move(senderCopy), senderId, &executor](this auto&& self, std::size_t i) -> void { - if (i >= kVALUES_PER_SENDER) + if (i >= kValuesPerSender) return; senderCopy.asyncSend( @@ -456,10 +456,10 @@ TEST_P(ChannelCallbackTest, MultipleSendersMultipleReceivers) context_.run(); - EXPECT_EQ(receivedValues.lock()->size(), kTOTAL_EXPECTED); + EXPECT_EQ(receivedValues.lock()->size(), kTotalExpected); std::ranges::sort(receivedValues.lock().get()); - EXPECT_EQ(receivedValues.lock().get(), kEXPECTED_VALUES); + EXPECT_EQ(receivedValues.lock().get(), kExpectedValues); }); } @@ -620,7 +620,7 @@ TEST(ChannelTest, MultipleSenderCopiesErrorHandling) testCompleted = true; }); - executor.run_for(kTEST_TIMEOUT); + executor.run_for(kTestTimeout); EXPECT_TRUE(testCompleted); } @@ -706,7 +706,7 @@ TEST(ChannelTest, ChannelPreservesOrderFIFO) } ); - executor.run_for(kTEST_TIMEOUT); + executor.run_for(kTestTimeout); EXPECT_TRUE(testCompleted); } @@ -735,7 +735,7 @@ TEST(ChannelTest, AsyncReceiveWakesUpWhenSenderDestroyed) } ); - executor.run_for(kTEST_TIMEOUT); + executor.run_for(kTestTimeout); EXPECT_TRUE(testCompleted); } @@ -746,16 +746,16 @@ TEST(ChannelTest, AsyncReceiveWakesUpWhenSenderDestroyed) TEST(ChannelTest, PendingAsyncSendsAreCancelledOnClose) { boost::asio::thread_pool pool{4}; - static constexpr auto kPENDING_NUM_SENDERS = 10uz; + static constexpr auto kPendingNumSenders = 10uz; // Channel with capacity 0 - all sends will block waiting for a receiver auto [sender, receiver] = util::Channel::create(pool, 0); std::atomic completedSends{0}; - std::counting_semaphore semaphore{kPENDING_NUM_SENDERS}; + std::counting_semaphore semaphore{kPendingNumSenders}; // Spawn multiple senders that will all block (no receiver is consuming) - for (auto i = 0uz; i < kPENDING_NUM_SENDERS; ++i) { + for (auto i = 0uz; i < kPendingNumSenders; ++i) { util::spawn( pool, [senderCopy = sender, i, &completedSends, &semaphore]( @@ -780,7 +780,7 @@ TEST(ChannelTest, PendingAsyncSendsAreCancelledOnClose) pool.join(); // All sends should have completed (returned false due to closed channel) - EXPECT_EQ(completedSends, kPENDING_NUM_SENDERS); + EXPECT_EQ(completedSends, kPendingNumSenders); } INSTANTIATE_CHANNEL_FOR_CLANG(int); diff --git a/tests/unit/util/ConceptsTests.cpp b/tests/unit/util/ConceptsTests.cpp index 7cf032a64..d1b58e4f7 100644 --- a/tests/unit/util/ConceptsTests.cpp +++ b/tests/unit/util/ConceptsTests.cpp @@ -17,15 +17,15 @@ TEST(ConceptTests, hasNoDuplicates) } struct TestA { - static constexpr auto kNAME = "TestA"; + static constexpr auto kName = "TestA"; }; struct AnotherA { - static constexpr auto kNAME = "TestA"; + static constexpr auto kName = "TestA"; }; struct TestB { - static constexpr auto kNAME = "TestB"; + static constexpr auto kName = "TestB"; }; TEST(ConceptTests, hasNoDuplicateNames) diff --git a/tests/unit/util/LedgerUtilsTests.cpp b/tests/unit/util/LedgerUtilsTests.cpp index 42c1cfe5e..29687fd66 100644 --- a/tests/unit/util/LedgerUtilsTests.cpp +++ b/tests/unit/util/LedgerUtilsTests.cpp @@ -13,8 +13,8 @@ TEST(LedgerUtilsTests, LedgerObjectTypeList) { - constexpr auto kTYPES = util::LedgerTypes::getLedgerEntryTypeStrList(); - static constexpr char const* kTYPES_LIST[] = { + constexpr auto kTypes = util::LedgerTypes::getLedgerEntryTypeStrList(); + static constexpr char const* kTypesList[] = { JS(account), JS(amendments), JS(check), @@ -45,9 +45,9 @@ TEST(LedgerUtilsTests, LedgerObjectTypeList) JS(delegate) }; - static_assert(std::size(kTYPES_LIST) == kTYPES.size()); - static_assert(std::ranges::all_of(kTYPES_LIST, [&kTYPES](std::string_view type) { - return std::ranges::find(kTYPES, type) != std::cend(kTYPES); + static_assert(std::size(kTypesList) == kTypes.size()); + static_assert(std::ranges::all_of(kTypesList, [&kTypes](std::string_view type) { + return std::ranges::find(kTypes, type) != std::cend(kTypes); })); } @@ -60,17 +60,17 @@ TEST(LedgerUtilsTests, StrToType) EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("AccountRoot"), ripple::ltACCOUNT_ROOT); EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("ACCOUNTRoot"), ripple::ltACCOUNT_ROOT); - constexpr auto kTYPES = util::LedgerTypes::getLedgerEntryTypeStrList(); - std::ranges::for_each(kTYPES, [](auto const& typeStr) { + constexpr auto kTypes = util::LedgerTypes::getLedgerEntryTypeStrList(); + std::ranges::for_each(kTypes, [](auto const& typeStr) { EXPECT_NE(util::LedgerTypes::getLedgerEntryTypeFromStr(typeStr), ripple::ltANY); }); } TEST(LedgerUtilsTests, DeletionBlockerTypes) { - constexpr auto kTESTED_TYPES = util::LedgerTypes::getDeletionBlockerLedgerTypes(); + constexpr auto kTestedTypes = util::LedgerTypes::getDeletionBlockerLedgerTypes(); - static constexpr ripple::LedgerEntryType kDELETION_BLOCKERS[] = { + static constexpr ripple::LedgerEntryType kDeletionBlockers[] = { ripple::ltCHECK, ripple::ltESCROW, ripple::ltNFTOKEN_PAGE, @@ -84,10 +84,10 @@ TEST(LedgerUtilsTests, DeletionBlockerTypes) ripple::ltPERMISSIONED_DOMAIN }; - static_assert(std::size(kDELETION_BLOCKERS) == kTESTED_TYPES.size()); - static_assert(std::ranges::any_of(kTESTED_TYPES, [](auto const& type) { - return std::find(std::cbegin(kDELETION_BLOCKERS), std::cend(kDELETION_BLOCKERS), type) != - std::cend(kDELETION_BLOCKERS); + static_assert(std::size(kDeletionBlockers) == kTestedTypes.size()); + static_assert(std::ranges::any_of(kTestedTypes, [](auto const& type) { + return std::find(std::cbegin(kDeletionBlockers), std::cend(kDeletionBlockers), type) != + std::cend(kDeletionBlockers); })); } @@ -96,7 +96,7 @@ struct LedgerEntryTypeParam { ripple::LedgerEntryType expected; }; -static LedgerEntryTypeParam const kCHAIN_TEST_CASES[] = { +static LedgerEntryTypeParam const kChainTestCases[] = { // Using RPC name with exact match {.input = "amendments", .expected = ripple::ltAMENDMENTS}, {.input = "directory", .expected = ripple::ltDIR_NODE}, @@ -112,7 +112,7 @@ static LedgerEntryTypeParam const kCHAIN_TEST_CASES[] = { {.input = "NegativeUNL", .expected = ripple::ltNEGATIVE_UNL} }; -static LedgerEntryTypeParam const kACCOUNT_OWNED_TEST_CASES[] = { +static LedgerEntryTypeParam const kAccountOwnedTestCases[] = { // Using RPC name with exact match {.input = "account", .expected = ripple::ltACCOUNT_ROOT}, {.input = "check", .expected = ripple::ltCHECK}, @@ -166,14 +166,14 @@ static LedgerEntryTypeParam const kACCOUNT_OWNED_TEST_CASES[] = { {.input = "Delegate", .expected = ripple::ltDELEGATE} }; -static LedgerEntryTypeParam const kCASE_INSENSITIVE_TEST_CASES[] = { +static LedgerEntryTypeParam const kCaseInsensitiveTestCases[] = { // With canonical name in mixedcase {.input = "mPtOKenIssuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, // With canonical name in lowercase {.input = "mptokenissuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, }; -static LedgerEntryTypeParam const kINVALID_TEST_CASES[] = { +static LedgerEntryTypeParam const kInvalidTestCases[] = { {.input = "", .expected = ripple::ltANY}, {.input = "1234", .expected = ripple::ltANY}, {.input = "unknown", .expected = ripple::ltANY}, @@ -195,16 +195,12 @@ INSTANTIATE_TEST_SUITE_P( LedgerEntryTypeFromStrTest, ::testing::ValuesIn([]() { std::vector v; - v.insert(v.end(), std::begin(kCHAIN_TEST_CASES), std::end(kCHAIN_TEST_CASES)); + v.insert(v.end(), std::begin(kChainTestCases), std::end(kChainTestCases)); + v.insert(v.end(), std::begin(kAccountOwnedTestCases), std::end(kAccountOwnedTestCases)); v.insert( - v.end(), std::begin(kACCOUNT_OWNED_TEST_CASES), std::end(kACCOUNT_OWNED_TEST_CASES) + v.end(), std::begin(kCaseInsensitiveTestCases), std::end(kCaseInsensitiveTestCases) ); - v.insert( - v.end(), - std::begin(kCASE_INSENSITIVE_TEST_CASES), - std::end(kCASE_INSENSITIVE_TEST_CASES) - ); - v.insert(v.end(), std::begin(kINVALID_TEST_CASES), std::end(kINVALID_TEST_CASES)); + v.insert(v.end(), std::begin(kInvalidTestCases), std::end(kInvalidTestCases)); return v; }()) ); @@ -223,15 +219,11 @@ INSTANTIATE_TEST_SUITE_P( AccountOwnedLedgerTypeFromStrTest, ::testing::ValuesIn([]() { std::vector v; + v.insert(v.end(), std::begin(kAccountOwnedTestCases), std::end(kAccountOwnedTestCases)); v.insert( - v.end(), std::begin(kACCOUNT_OWNED_TEST_CASES), std::end(kACCOUNT_OWNED_TEST_CASES) + v.end(), std::begin(kCaseInsensitiveTestCases), std::end(kCaseInsensitiveTestCases) ); - v.insert( - v.end(), - std::begin(kCASE_INSENSITIVE_TEST_CASES), - std::end(kCASE_INSENSITIVE_TEST_CASES) - ); - v.insert(v.end(), std::begin(kINVALID_TEST_CASES), std::end(kINVALID_TEST_CASES)); + v.insert(v.end(), std::begin(kInvalidTestCases), std::end(kInvalidTestCases)); v.push_back({"amendments", ripple::ltANY}); // chain type should return ltANY return v; }()) diff --git a/tests/unit/util/ObservableValueAtomicTest.cpp b/tests/unit/util/ObservableValueAtomicTest.cpp index 4837fb4ae..05cf9a5a0 100644 --- a/tests/unit/util/ObservableValueAtomicTest.cpp +++ b/tests/unit/util/ObservableValueAtomicTest.cpp @@ -157,15 +157,15 @@ TEST_F(ObservableValueAtomicTest, ThreadSafetyBasic) values.push_back(value); }); - static constexpr auto kNUM_THREADS = 4; - static constexpr auto kINCREMENTS_PER_THREAD = 100; + static constexpr auto kNumThreads = 4; + static constexpr auto kIncrementsPerThread = 100; std::vector threads; - threads.reserve(kNUM_THREADS); + threads.reserve(kNumThreads); - for (int i = 0; i < kNUM_THREADS; ++i) { + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back([&obs]() { - for (int j = 0; j < kINCREMENTS_PER_THREAD; ++j) { + for (int j = 0; j < kIncrementsPerThread; ++j) { int const expected = obs.get(); int const newValue = expected + 1; obs.set(newValue); @@ -194,15 +194,15 @@ TEST_F(ObservableValueAtomicTest, ThreadSafetyWithDirectAccess) auto connection = obs.observe([&](int const&) { notificationCount.fetch_add(1); }); - static constexpr auto kNUM_THREADS = 4; - static constexpr auto kOPERATIONS_PER_THREAD = 50; + static constexpr auto kNumThreads = 4; + static constexpr auto kOperationsPerThread = 50; std::vector threads; - threads.reserve(kNUM_THREADS); + threads.reserve(kNumThreads); - for (int i = 0; i < kNUM_THREADS; ++i) { + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back([&obs]() { - for (int j = 0; j < kOPERATIONS_PER_THREAD; ++j) { + for (int j = 0; j < kOperationsPerThread; ++j) { int const current = obs.get(); obs.set(current + 1); std::this_thread::sleep_for(std::chrono::microseconds(1)); @@ -262,15 +262,15 @@ TEST_F(ObservableValueAtomicTest, RaceConditionNotificationIntegrity) values.push_back(value); }); - static constexpr auto kNUM_THREADS = 10; - static constexpr auto kOPERATIONS_PER_THREAD = 20; + static constexpr auto kNumThreads = 10; + static constexpr auto kOperationsPerThread = 20; std::vector threads; - threads.reserve(kNUM_THREADS); + threads.reserve(kNumThreads); - for (int i = 0; i < kNUM_THREADS; ++i) { + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back([&obs]() { - for (int j = 0; j < kOPERATIONS_PER_THREAD; ++j) { + for (int j = 0; j < kOperationsPerThread; ++j) { obs.set(j % 3); std::this_thread::sleep_for(std::chrono::microseconds(1)); } @@ -306,12 +306,12 @@ TEST_F(ObservableValueAtomicTest, DeterministicNotificationTest) values.push_back(value); }); - static constexpr auto kNUM_THREADS = 5; + static constexpr auto kNumThreads = 5; std::vector threads; - threads.reserve(kNUM_THREADS); + threads.reserve(kNumThreads); - for (int i = 0; i < kNUM_THREADS; ++i) { + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back([&obs, i]() { obs.set(i + 1); }); } @@ -319,19 +319,19 @@ TEST_F(ObservableValueAtomicTest, DeterministicNotificationTest) thread.join(); // Each thread sets a unique value, so expect exactly kNumThreads notifications - EXPECT_EQ(notificationCount.load(), kNUM_THREADS); + EXPECT_EQ(notificationCount.load(), kNumThreads); std::scoped_lock const lock(valuesMutex); - EXPECT_EQ(values.size(), kNUM_THREADS); + EXPECT_EQ(values.size(), kNumThreads); for (auto const& value : values) { EXPECT_GE(value, 1); - EXPECT_LE(value, kNUM_THREADS); + EXPECT_LE(value, kNumThreads); } int const finalValue = obs.get(); EXPECT_GE(finalValue, 1); - EXPECT_LE(finalValue, kNUM_THREADS); + EXPECT_LE(finalValue, kNumThreads); } TEST_F(ObservableValueAtomicTest, NoNotificationForSameValue) @@ -341,12 +341,12 @@ TEST_F(ObservableValueAtomicTest, NoNotificationForSameValue) auto connection = obs.observe([&](int const&) { notificationCount.fetch_add(1); }); - static constexpr auto kNUM_THREADS = 10; + static constexpr auto kNumThreads = 10; std::vector threads; - threads.reserve(kNUM_THREADS); + threads.reserve(kNumThreads); - for (int i = 0; i < kNUM_THREADS; ++i) { + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back([&obs]() { obs.set(42); }); } @@ -370,14 +370,14 @@ TEST_F(ObservableValueAtomicTest, AtomicRaceConditionCorrectness) values.push_back(value); }); - static constexpr auto kNUM_THREADS = 3; + static constexpr auto kNumThreads = 3; std::vector threads; - threads.reserve(kNUM_THREADS); + threads.reserve(kNumThreads); // Test that direct access properly notifies for all value changes // Each thread will make unique changes to avoid race condition conflicts - for (int i = 0; i < kNUM_THREADS; ++i) { + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back([&obs, i]() { int const baseValue = (i + 1) * 10; // 10, 20, 30 obs.set(baseValue); // Store unique values @@ -390,10 +390,10 @@ TEST_F(ObservableValueAtomicTest, AtomicRaceConditionCorrectness) // We should get some notifications (exact count depends on race conditions) // but at least one per thread since they use unique base values - EXPECT_GE(notificationCount.load(), kNUM_THREADS); + EXPECT_GE(notificationCount.load(), kNumThreads); std::scoped_lock const lock(valuesMutex); - EXPECT_GE(values.size(), kNUM_THREADS); + EXPECT_GE(values.size(), kNumThreads); for (auto const& value : values) EXPECT_GT(value, 0); diff --git a/tests/unit/util/ObservableValueTest.cpp b/tests/unit/util/ObservableValueTest.cpp index d8f3eccd2..22d3dc2fb 100644 --- a/tests/unit/util/ObservableValueTest.cpp +++ b/tests/unit/util/ObservableValueTest.cpp @@ -531,8 +531,8 @@ TEST_F(ObservableValueTest, ManyObservers) mockObservers; std::vector connections; - constexpr int kNUM_OBSERVERS = 100; - for (int i = 0; i < kNUM_OBSERVERS; ++i) { + constexpr int kNumObservers = 100; + for (int i = 0; i < kNumObservers; ++i) { mockObservers.push_back( std::make_unique>>() ); diff --git a/tests/unit/util/ShasumTests.cpp b/tests/unit/util/ShasumTests.cpp index deadc655e..573c21803 100644 --- a/tests/unit/util/ShasumTests.cpp +++ b/tests/unit/util/ShasumTests.cpp @@ -10,9 +10,9 @@ using namespace util; struct ShasumTest : testing::Test { - static constexpr auto kEMPTY_HASH = + static constexpr auto kEmptyHash = "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"; - static constexpr auto kHELLO_WORLD_HASH = + static constexpr auto kHelloWorldHash = "B94D27B9934D3E08A52E52D7DA7DABFAC484EFE37A5380EE9088F7ACE2EFCDE9"; }; @@ -20,17 +20,17 @@ TEST_F(ShasumTest, sha256sum) { ripple::uint256 expected; - ASSERT_TRUE(expected.parseHex(kEMPTY_HASH)); + ASSERT_TRUE(expected.parseHex(kEmptyHash)); EXPECT_EQ(sha256sum(""), expected); - ASSERT_TRUE(expected.parseHex(kHELLO_WORLD_HASH)); + ASSERT_TRUE(expected.parseHex(kHelloWorldHash)); EXPECT_EQ(sha256sum("hello world"), expected); } TEST_F(ShasumTest, sha256sumString) { - EXPECT_EQ(sha256sumString(""), kEMPTY_HASH); - EXPECT_EQ(sha256sumString("hello world"), kHELLO_WORLD_HASH); + EXPECT_EQ(sha256sumString(""), kEmptyHash); + EXPECT_EQ(sha256sumString("hello world"), kHelloWorldHash); } TEST_F(ShasumTest, Sha256sumStreamingEmpty) @@ -39,7 +39,7 @@ TEST_F(ShasumTest, Sha256sumStreamingEmpty) auto result = std::move(hasher).finalize(); ripple::uint256 expected; - ASSERT_TRUE(expected.parseHex(kEMPTY_HASH)); + ASSERT_TRUE(expected.parseHex(kEmptyHash)); EXPECT_EQ(result, expected); } @@ -51,7 +51,7 @@ TEST_F(ShasumTest, Sha256sumStreamingSingleUpdate) auto result = std::move(hasher).finalize(); ripple::uint256 expected; - ASSERT_TRUE(expected.parseHex(kHELLO_WORLD_HASH)); + ASSERT_TRUE(expected.parseHex(kHelloWorldHash)); EXPECT_EQ(result, expected); } @@ -64,7 +64,7 @@ TEST_F(ShasumTest, Sha256sumStreamingMultipleUpdates) auto result = std::move(hasher).finalize(); ripple::uint256 expected; - ASSERT_TRUE(expected.parseHex(kHELLO_WORLD_HASH)); + ASSERT_TRUE(expected.parseHex(kHelloWorldHash)); EXPECT_EQ(result, expected); } diff --git a/tests/unit/util/async/AsyncExecutionContextTests.cpp b/tests/unit/util/async/AsyncExecutionContextTests.cpp index e54f76aec..194f340ee 100644 --- a/tests/unit/util/async/AsyncExecutionContextTests.cpp +++ b/tests/unit/util/async/AsyncExecutionContextTests.cpp @@ -238,10 +238,10 @@ TYPED_TEST(ExecutionContextTests, submit) std::atomic_uint32_t count = 0; std::binary_semaphore sem{0}; - static constexpr auto kNUM_SUBMISSIONS = 1024; + static constexpr auto kNumSubmissions = 1024; - for (auto i = 1; i <= kNUM_SUBMISSIONS; ++i) { - if (i == kNUM_SUBMISSIONS) { + for (auto i = 1; i <= kNumSubmissions; ++i) { + if (i == kNumSubmissions) { this->ctx.submit([&count, &sem] { ++count; sem.release(); @@ -254,7 +254,7 @@ TYPED_TEST(ExecutionContextTests, submit) sem.acquire(); // order is not guaranteed (see `strandSubmit` below) - ASSERT_EQ(count, static_cast(kNUM_SUBMISSIONS)); + ASSERT_EQ(count, static_cast(kNumSubmissions)); } TYPED_TEST(ExecutionContextTests, strandMove) @@ -359,10 +359,10 @@ TYPED_TEST(ExecutionContextTests, strandSubmit) std::vector results; std::binary_semaphore sem{0}; - static constexpr auto kNUM_SUBMISSIONS = 1024; + static constexpr auto kNumSubmissions = 1024; - for (auto i = 1; i <= kNUM_SUBMISSIONS; ++i) { - if (i == kNUM_SUBMISSIONS) { + for (auto i = 1; i <= kNumSubmissions; ++i) { + if (i == kNumSubmissions) { strand.submit([&results, &sem, i] { results.push_back(i); sem.release(); @@ -374,8 +374,8 @@ TYPED_TEST(ExecutionContextTests, strandSubmit) sem.acquire(); - ASSERT_EQ(results.size(), static_cast(kNUM_SUBMISSIONS)); - for (int i = 0; i < kNUM_SUBMISSIONS; ++i) { + ASSERT_EQ(results.size(), static_cast(kNumSubmissions)); + for (int i = 0; i < kNumSubmissions; ++i) { EXPECT_EQ(results[i], i + 1); } } diff --git a/tests/unit/util/config/ArrayViewTests.cpp b/tests/unit/util/config/ArrayViewTests.cpp index 48dbb766b..f144fc443 100644 --- a/tests/unit/util/config/ArrayViewTests.cpp +++ b/tests/unit/util/config/ArrayViewTests.cpp @@ -18,7 +18,7 @@ using namespace util::config; struct ArrayViewTest : virtual testing::Test { ArrayViewTest() { - ConfigFileJson const jsonFileObj{boost::json::parse(kJSON_DATA).as_object()}; + ConfigFileJson const jsonFileObj{boost::json::parse(kJsonData).as_object()}; auto const errors = configData.parse(jsonFileObj); EXPECT_TRUE(!errors.has_value()); } diff --git a/tests/unit/util/config/ClioConfigDefinitionTests.cpp b/tests/unit/util/config/ClioConfigDefinitionTests.cpp index f57814820..ae800bdd1 100644 --- a/tests/unit/util/config/ClioConfigDefinitionTests.cpp +++ b/tests/unit/util/config/ClioConfigDefinitionTests.cpp @@ -184,7 +184,7 @@ TEST_F(ConfigDescriptionAssertTest, NonExistingKeyTest) struct OverrideConfigVals : testing::Test { OverrideConfigVals() { - ConfigFileJson const jsonFileObj{boost::json::parse(kJSON_DATA).as_object()}; + ConfigFileJson const jsonFileObj{boost::json::parse(kJsonData).as_object()}; auto const errors = configData.parse(jsonFileObj); EXPECT_TRUE(!errors.has_value()); } @@ -298,7 +298,7 @@ struct IncorrectOverrideValues : testing::Test { TEST_F(IncorrectOverrideValues, InvalidJsonErrors) { - ConfigFileJson const jsonFileObj{boost::json::parse(kINVALID_JSON_DATA).as_object()}; + ConfigFileJson const jsonFileObj{boost::json::parse(kInvalidJsonData).as_object()}; auto const errors = configData.parse(jsonFileObj); EXPECT_TRUE(errors.has_value()); diff --git a/tests/unit/util/config/ConfigFileJsonTests.cpp b/tests/unit/util/config/ConfigFileJsonTests.cpp index 973f38ddf..501f86f73 100644 --- a/tests/unit/util/config/ConfigFileJsonTests.cpp +++ b/tests/unit/util/config/ConfigFileJsonTests.cpp @@ -19,7 +19,7 @@ using namespace util::config; namespace { -constexpr auto kEPS = 1e-9; +constexpr auto kEps = 1e-9; } // namespace struct ConfigFileJsonParseTestBundle { @@ -56,7 +56,7 @@ TEST_P(ConfigFileJsonParseTest, parseValues) }, [&flatJson, &key](double const v) { EXPECT_TRUE(flatJson.at(key).is_double()) << key << ": " << v; - EXPECT_NEAR(flatJson.at(key).as_double(), v, kEPS) << key << ": " << v; + EXPECT_NEAR(flatJson.at(key).as_double(), v, kEps) << key << ": " << v; }, [&flatJson, &key](bool const v) { EXPECT_TRUE(flatJson.at(key).is_bool()) << key << ": " << v; @@ -296,7 +296,7 @@ INSTANTIATE_TEST_CASE_P( boost::json::array{boost::json::value{}, "some string"}}} } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct ConfigFileJsonTest : public virtual ::testing::Test {}; @@ -325,7 +325,7 @@ TEST_F(ConfigFileJsonTest, getValue) auto const doubleValue = jsonFileObj.getValue("double"); ASSERT_TRUE(std::holds_alternative(doubleValue)); - EXPECT_NEAR(std::get(doubleValue), 123.456, kEPS); + EXPECT_NEAR(std::get(doubleValue), 123.456, kEps); EXPECT_FALSE(jsonFileObj.containsKey("object.int")); } @@ -377,7 +377,7 @@ TEST_F(ConfigFileJsonTest, getArray) auto const value2 = (*array.at(2)); // NOLINT(bugprone-unchecked-optional-access) ASSERT_TRUE(std::holds_alternative(value2)); - EXPECT_NEAR(std::get(value2), 3.14, kEPS); + EXPECT_NEAR(std::get(value2), 3.14, kEps); auto const value3 = (*array.at(3)); // NOLINT(bugprone-unchecked-optional-access) ASSERT_TRUE(std::holds_alternative(value3)); diff --git a/tests/unit/util/config/ObjectViewTests.cpp b/tests/unit/util/config/ObjectViewTests.cpp index 5d9a9a5c9..67e384e9d 100644 --- a/tests/unit/util/config/ObjectViewTests.cpp +++ b/tests/unit/util/config/ObjectViewTests.cpp @@ -16,7 +16,7 @@ using namespace util::config; struct ObjectViewTest : virtual testing::Test { ObjectViewTest() { - ConfigFileJson const jsonFileObj{boost::json::parse(kJSON_DATA).as_object()}; + ConfigFileJson const jsonFileObj{boost::json::parse(kJsonData).as_object()}; auto const errors = configData.parse(jsonFileObj); EXPECT_TRUE(!errors.has_value()); } diff --git a/tests/unit/util/log/LogServiceInitTests.cpp b/tests/unit/util/log/LogServiceInitTests.cpp index eab7a072f..931f45920 100644 --- a/tests/unit/util/log/LogServiceInitTests.cpp +++ b/tests/unit/util/log/LogServiceInitTests.cpp @@ -88,7 +88,7 @@ TEST_F(LogServiceInitTests, DefaultLogLevel) EXPECT_TRUE(LogService::init(config_)); std::string const logString = "some log"; - for (std::string_view const channel : Logger::kCHANNELS) { + for (std::string_view const channel : Logger::kChannels) { Logger const log{channel}; log.trace() << logString; auto loggerStr = getLoggerString(); @@ -131,7 +131,7 @@ TEST_F(LogServiceInitTests, ChannelLogLevel) EXPECT_TRUE(LogService::init(config_)); std::string const logString = "some log"; - for (auto const& channel : Logger::kCHANNELS) { + for (auto const& channel : Logger::kChannels) { Logger const log{channel}; log.trace() << logString; ASSERT_TRUE(getLoggerString().empty()); diff --git a/tests/unit/util/log/LoggerTests.cpp b/tests/unit/util/log/LoggerTests.cpp index 8f523f4a7..98f40ce8a 100644 --- a/tests/unit/util/log/LoggerTests.cpp +++ b/tests/unit/util/log/LoggerTests.cpp @@ -84,11 +84,11 @@ TEST_F(LoggerTest, LOGMacro) TEST_F(LoggerTest, ManyDynamicLoggers) { - static constexpr size_t kNUM_LOGGERS = 10'000; + static constexpr size_t kNumLoggers = 10'000; auto initialLoggers = loggersNum(); - for (size_t i = 0; i < kNUM_LOGGERS; ++i) { + for (size_t i = 0; i < kNumLoggers; ++i) { std::string const loggerName = "DynamicLogger" + std::to_string(i); Logger const log{loggerName}; diff --git a/tests/unit/util/log/PrettyPathTests.cpp b/tests/unit/util/log/PrettyPathTests.cpp index 67cf33304..f511c6404 100644 --- a/tests/unit/util/log/PrettyPathTests.cpp +++ b/tests/unit/util/log/PrettyPathTests.cpp @@ -16,31 +16,31 @@ TEST(PrettyPath, CurrentFile) } struct PrettyPathDepth : public common::util::WithMockAssert { - static constexpr std::string_view kTEST_PATH = "my/awesome/path/to/file.cpp"; + static constexpr std::string_view kTestPath = "my/awesome/path/to/file.cpp"; }; TEST_F(PrettyPathDepth, Zero) { EXPECT_CLIO_ASSERT_FAIL_WITH_MESSAGE( - { [[maybe_unused]] auto unused = prettyPath(kTEST_PATH, 0); }, + { [[maybe_unused]] auto unused = prettyPath(kTestPath, 0); }, "maxDepth must be greater than 0" ); } TEST_F(PrettyPathDepth, Small) { - auto pretty = prettyPath(kTEST_PATH, 1); + auto pretty = prettyPath(kTestPath, 1); EXPECT_EQ(pretty, "file.cpp"); } TEST_F(PrettyPathDepth, Big) { - auto pretty = prettyPath(kTEST_PATH, 4); + auto pretty = prettyPath(kTestPath, 4); EXPECT_EQ(pretty, "awesome/path/to/file.cpp"); } TEST_F(PrettyPathDepth, MoreThanParts) { - auto pretty = prettyPath(kTEST_PATH, 10); + auto pretty = prettyPath(kTestPath, 10); EXPECT_EQ(pretty, "my/awesome/path/to/file.cpp"); } diff --git a/tests/unit/util/prometheus/CounterTests.cpp b/tests/unit/util/prometheus/CounterTests.cpp index 869fbf103..f97f773ae 100644 --- a/tests/unit/util/prometheus/CounterTests.cpp +++ b/tests/unit/util/prometheus/CounterTests.cpp @@ -103,22 +103,22 @@ TEST_F(CounterIntTests, reset) TEST_F(CounterIntTests, multithreadAdd) { - static constexpr auto kNUM_ADDITIONS = 1000; - static constexpr auto kNUM_NUMBER_ADDITIONS = 100; - static constexpr auto kNUMBER_TO_ADD = 11; + static constexpr auto kNumAdditions = 1000; + static constexpr auto kNumNumberAdditions = 100; + static constexpr auto kNumberToAdd = 11; std::thread thread1([&] { - for (int i = 0; i < kNUM_ADDITIONS; ++i) { + for (int i = 0; i < kNumAdditions; ++i) { ++counter; } }); std::thread thread2([&] { - for (int i = 0; i < kNUM_NUMBER_ADDITIONS; ++i) { - counter += kNUMBER_TO_ADD; + for (int i = 0; i < kNumNumberAdditions; ++i) { + counter += kNumberToAdd; } }); thread1.join(); thread2.join(); - EXPECT_EQ(counter.value(), kNUM_ADDITIONS + (kNUM_NUMBER_ADDITIONS * kNUMBER_TO_ADD)); + EXPECT_EQ(counter.value(), kNumAdditions + (kNumNumberAdditions * kNumberToAdd)); } struct CounterDoubleTests : ::testing::Test { @@ -142,20 +142,20 @@ TEST_F(CounterDoubleTests, reset) TEST_F(CounterDoubleTests, multithreadAdd) { - static constexpr auto kNUM_ADDITIONS = 1000; - static constexpr auto kNUM_NUMBER_ADDITIONS = 100; - static constexpr auto kNUMBER_TO_ADD = 11.1234; + static constexpr auto kNumAdditions = 1000; + static constexpr auto kNumNumberAdditions = 100; + static constexpr auto kNumberToAdd = 11.1234; std::thread thread1([&] { - for (int i = 0; i < kNUM_ADDITIONS; ++i) { + for (int i = 0; i < kNumAdditions; ++i) { ++counter; } }); std::thread thread2([&] { - for (int i = 0; i < kNUM_NUMBER_ADDITIONS; ++i) { - counter += kNUMBER_TO_ADD; + for (int i = 0; i < kNumNumberAdditions; ++i) { + counter += kNumberToAdd; } }); thread1.join(); thread2.join(); - EXPECT_NEAR(counter.value(), kNUM_ADDITIONS + (kNUM_NUMBER_ADDITIONS * kNUMBER_TO_ADD), 1e-9); + EXPECT_NEAR(counter.value(), kNumAdditions + (kNumNumberAdditions * kNumberToAdd), 1e-9); } diff --git a/tests/unit/util/prometheus/GaugeTests.cpp b/tests/unit/util/prometheus/GaugeTests.cpp index abf9774b3..1e6416a6f 100644 --- a/tests/unit/util/prometheus/GaugeTests.cpp +++ b/tests/unit/util/prometheus/GaugeTests.cpp @@ -77,30 +77,30 @@ TEST_F(GaugeIntTests, set) TEST_F(GaugeIntTests, multithreadAddAndSubtract) { - static constexpr auto kNUM_ADDITIONS = 1000; - static constexpr auto kNUM_NUMBER_ADDITIONS = 100; - static constexpr auto kNUMBER_TO_ADD = 11; - static constexpr auto kNUM_SUBTRACTIONS = 2000; - static constexpr auto kNUM_NUMBER_SUBTRACTIONS = 300; - static constexpr auto kNUMBER_TO_SUBTRACT = 300; + static constexpr auto kNumAdditions = 1000; + static constexpr auto kNumNumberAdditions = 100; + static constexpr auto kNumberToAdd = 11; + static constexpr auto kNumSubtractions = 2000; + static constexpr auto kNumNumberSubtractions = 300; + static constexpr auto kNumberToSubtract = 300; std::thread thread1([&] { - for (int i = 0; i < kNUM_ADDITIONS; ++i) { + for (int i = 0; i < kNumAdditions; ++i) { ++gauge; } }); std::thread thread2([&] { - for (int i = 0; i < kNUM_NUMBER_ADDITIONS; ++i) { - gauge += kNUMBER_TO_ADD; + for (int i = 0; i < kNumNumberAdditions; ++i) { + gauge += kNumberToAdd; } }); std::thread thread3([&] { - for (int i = 0; i < kNUM_SUBTRACTIONS; ++i) { + for (int i = 0; i < kNumSubtractions; ++i) { --gauge; } }); std::thread thread4([&] { - for (int i = 0; i < kNUM_NUMBER_SUBTRACTIONS; ++i) { - gauge -= kNUMBER_TO_SUBTRACT; + for (int i = 0; i < kNumNumberSubtractions; ++i) { + gauge -= kNumberToSubtract; } }); thread1.join(); @@ -109,8 +109,8 @@ TEST_F(GaugeIntTests, multithreadAddAndSubtract) thread4.join(); EXPECT_EQ( gauge.value(), - kNUM_ADDITIONS + (kNUM_NUMBER_ADDITIONS * kNUMBER_TO_ADD) - kNUM_SUBTRACTIONS - - (kNUM_NUMBER_SUBTRACTIONS * kNUMBER_TO_SUBTRACT) + kNumAdditions + (kNumNumberAdditions * kNumberToAdd) - kNumSubtractions - + (kNumNumberSubtractions * kNumberToSubtract) ); } @@ -151,30 +151,30 @@ TEST_F(GaugeDoubleTests, set) TEST_F(GaugeDoubleTests, multithreadAddAndSubtract) { - static constexpr auto kNUM_ADDITIONS = 1000; - static constexpr auto kNUM_NUMBER_ADDITIONS = 100; - static constexpr auto kNUMBER_TO_ADD = 11.1234; - static constexpr auto kNUM_SUBTRACTIONS = 2000; - static constexpr auto kNUM_NUMBER_SUBTRACTIONS = 300; - static constexpr auto kNUMBER_TO_SUBTRACT = 300.321; + static constexpr auto kNumAdditions = 1000; + static constexpr auto kNumNumberAdditions = 100; + static constexpr auto kNumberToAdd = 11.1234; + static constexpr auto kNumSubtractions = 2000; + static constexpr auto kNumNumberSubtractions = 300; + static constexpr auto kNumberToSubtract = 300.321; std::thread thread1([&] { - for (int i = 0; i < kNUM_ADDITIONS; ++i) { + for (int i = 0; i < kNumAdditions; ++i) { ++gauge; } }); std::thread thread2([&] { - for (int i = 0; i < kNUM_NUMBER_ADDITIONS; ++i) { - gauge += kNUMBER_TO_ADD; + for (int i = 0; i < kNumNumberAdditions; ++i) { + gauge += kNumberToAdd; } }); std::thread thread3([&] { - for (int i = 0; i < kNUM_SUBTRACTIONS; ++i) { + for (int i = 0; i < kNumSubtractions; ++i) { --gauge; } }); std::thread thread4([&] { - for (int i = 0; i < kNUM_NUMBER_SUBTRACTIONS; ++i) { - gauge -= kNUMBER_TO_SUBTRACT; + for (int i = 0; i < kNumNumberSubtractions; ++i) { + gauge -= kNumberToSubtract; } }); thread1.join(); @@ -183,8 +183,8 @@ TEST_F(GaugeDoubleTests, multithreadAddAndSubtract) thread4.join(); EXPECT_NEAR( gauge.value(), - kNUM_ADDITIONS + (kNUM_NUMBER_ADDITIONS * kNUMBER_TO_ADD) - kNUM_SUBTRACTIONS - - (kNUM_NUMBER_SUBTRACTIONS * kNUMBER_TO_SUBTRACT), + kNumAdditions + (kNumNumberAdditions * kNumberToAdd) - kNumSubtractions - + (kNumNumberSubtractions * kNumberToSubtract), 1e-9 ); } diff --git a/tests/unit/util/prometheus/HttpTests.cpp b/tests/unit/util/prometheus/HttpTests.cpp index 811c32714..8ee6636b6 100644 --- a/tests/unit/util/prometheus/HttpTests.cpp +++ b/tests/unit/util/prometheus/HttpTests.cpp @@ -87,7 +87,7 @@ INSTANTIATE_TEST_CASE_P( .expected = false }, }), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct PrometheusHandleRequestTestsBase { diff --git a/tests/unit/web/AdminVerificationTests.cpp b/tests/unit/web/AdminVerificationTests.cpp index a3af38ab9..e733437ec 100644 --- a/tests/unit/web/AdminVerificationTests.cpp +++ b/tests/unit/web/AdminVerificationTests.cpp @@ -175,5 +175,5 @@ INSTANTIATE_TEST_SUITE_P( .expectedError = false } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); diff --git a/tests/unit/web/ProxyIpResolverTests.cpp b/tests/unit/web/ProxyIpResolverTests.cpp index 96c5d91d0..2553b9734 100644 --- a/tests/unit/web/ProxyIpResolverTests.cpp +++ b/tests/unit/web/ProxyIpResolverTests.cpp @@ -69,7 +69,7 @@ TEST_F(ProxyIpResolverTest, FromConfig) EXPECT_EQ(proxyIpResolver.resolveClientIp(clientIp, headers), std::nullopt); EXPECT_EQ(proxyIpResolver.resolveClientIp(proxyIp, headers), clientIp); - headers.set(ProxyIpResolver::kPROXY_TOKEN_HEADER, proxyToken); + headers.set(ProxyIpResolver::kProxyTokenHeader, proxyToken); EXPECT_EQ(proxyIpResolver.resolveClientIp(clientIp, headers), clientIp); EXPECT_EQ(proxyIpResolver.resolveClientIp(proxyIp, headers), clientIp); EXPECT_EQ(proxyIpResolver.resolveClientIp("127.0.0.1", headers), clientIp); @@ -127,7 +127,7 @@ INSTANTIATE_TEST_SUITE_P( .proxyIps = {}, .proxyTokens = {"test_token"}, .headers = - {{std::string(ProxyIpResolver::kPROXY_TOKEN_HEADER), "test_token"}, + {{std::string(ProxyIpResolver::kProxyTokenHeader), "test_token"}, {std::string(http::to_string(http::field::forwarded)), "for=1.2.3.4"}}, .connectionIp = "5.6.7.8", .expectedIp = "1.2.3.4" @@ -136,7 +136,7 @@ INSTANTIATE_TEST_SUITE_P( .testName = "TrustedProxyTokenWithoutForwardedHeader", .proxyIps = {}, .proxyTokens = {"test_token"}, - .headers = {{std::string(ProxyIpResolver::kPROXY_TOKEN_HEADER), "test_token"}}, + .headers = {{std::string(ProxyIpResolver::kProxyTokenHeader), "test_token"}}, .connectionIp = "5.6.7.8", .expectedIp = std::nullopt }, @@ -145,7 +145,7 @@ INSTANTIATE_TEST_SUITE_P( .proxyIps = {}, .proxyTokens = {}, .headers = - {{std::string(ProxyIpResolver::kPROXY_TOKEN_HEADER), "test_token"}, + {{std::string(ProxyIpResolver::kProxyTokenHeader), "test_token"}, {std::string(http::to_string(http::field::forwarded)), "for=1.2.3.4"}}, .connectionIp = "5.6.7.8", .expectedIp = std::nullopt @@ -214,5 +214,5 @@ INSTANTIATE_TEST_SUITE_P( .expectedIp = "9.10.11.12" } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); diff --git a/tests/unit/web/RPCServerHandlerTests.cpp b/tests/unit/web/RPCServerHandlerTests.cpp index c815817f5..8f6c00a25 100644 --- a/tests/unit/web/RPCServerHandlerTests.cpp +++ b/tests/unit/web/RPCServerHandlerTests.cpp @@ -34,8 +34,8 @@ using namespace util::config; namespace { -constexpr auto kMIN_SEQ = 10; -constexpr auto kMAX_SEQ = 30; +constexpr auto kMinSeq = 10; +constexpr auto kMaxSeq = 30; } // namespace @@ -85,9 +85,9 @@ struct WebRPCServerHandlerTest : util::prometheus::WithPrometheus, util::config::ClioConfigDefinition cfg{ {"log.tag_style", ConfigValue{ConfigType::String}.defaultValue("none")}, {"api_version.default", - ConfigValue{ConfigType::Integer}.defaultValue(rpc::kAPI_VERSION_DEFAULT)}, - {"api_version.min", ConfigValue{ConfigType::Integer}.defaultValue(rpc::kAPI_VERSION_MIN)}, - {"api_version.max", ConfigValue{ConfigType::Integer}.defaultValue(rpc::kAPI_VERSION_MAX)} + ConfigValue{ConfigType::Integer}.defaultValue(rpc::kApiVersionDefault)}, + {"api_version.min", ConfigValue{ConfigType::Integer}.defaultValue(rpc::kApiVersionMin)}, + {"api_version.max", ConfigValue{ConfigType::Integer}.defaultValue(rpc::kApiVersionMax)} }; std::shared_ptr rpcEngine = std::make_shared(); std::shared_ptr etl = std::make_shared(); @@ -107,15 +107,15 @@ struct WebRPCServerHandlerTest : util::prometheus::WithPrometheus, TEST_F(WebRPCServerHandlerTest, HTTPDefaultPath) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESULT = "{}"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResult = "{}"; + static constexpr auto kResponse = R"JSON({ "result": { "status": "success" }, @@ -128,35 +128,35 @@ TEST_F(WebRPCServerHandlerTest, HTTPDefaultPath) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPRejectedByDosguard) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(false)); - (*handler)(kREQUEST, session); + (*handler)(kRequest, session); EXPECT_EQ(session->slowDownCallsCounter, 1); } TEST_F(WebRPCServerHandlerTest, HTTPRejectedByDosguardAfterParsing) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; @@ -165,23 +165,23 @@ TEST_F(WebRPCServerHandlerTest, HTTPRejectedByDosguardAfterParsing) EXPECT_CALL(dosguard, request(session->clientIp(), testing::_)) .WillOnce(testing::Return(false)); - (*handler)(kREQUEST, session); + (*handler)(kRequest, session); EXPECT_EQ(session->slowDownCallsCounter, 1); } TEST_F(WebRPCServerHandlerTest, WsNormalPath) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99, "api_version": 2 })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESULT = "{}"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResult = "{}"; + static constexpr auto kResponse = R"JSON({ "result": {}, "id": 99, "status": "success", @@ -195,23 +195,23 @@ TEST_F(WebRPCServerHandlerTest, WsNormalPath) ] })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsRejectedByDosguard) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99, "api_version": 2 @@ -219,44 +219,44 @@ TEST_F(WebRPCServerHandlerTest, WsRejectedByDosguard) EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(false)); - (*handler)(kREQUEST, session); + (*handler)(kRequest, session); EXPECT_EQ(session->slowDownCallsCounter, 1); } TEST_F(WebRPCServerHandlerTest, WsRejectedByDosguardAfterParsing) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99, "api_version": 2 })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(false)); - (*handler)(kREQUEST, session); + (*handler)(kRequest, session); EXPECT_EQ(session->slowDownCallsCounter, 1); } TEST_F(WebRPCServerHandlerTest, HTTPForwardedPath) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); // Note: forwarding always goes thru WS API - static constexpr auto kRESULT = R"JSON({ + static constexpr auto kResult = R"JSON({ "result": { "index": 1 }, "forwarded": true })JSON"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "index": 1, "status": "success" @@ -271,30 +271,30 @@ TEST_F(WebRPCServerHandlerTest, HTTPForwardedPath) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPForwardedErrorPath) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); // Note: forwarding always goes thru WS API - static constexpr auto kRESULT = R"JSON({ + static constexpr auto kResult = R"JSON({ "error": "error", "error_code": 123, "error_message": "error message", @@ -302,7 +302,7 @@ TEST_F(WebRPCServerHandlerTest, HTTPForwardedErrorPath) "type": "response", "forwarded": true })JSON"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "error": "error", "error_code": 123, @@ -320,37 +320,37 @@ TEST_F(WebRPCServerHandlerTest, HTTPForwardedErrorPath) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsForwardedPath) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99 })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); // Note: forwarding always goes thru WS API - static constexpr auto kRESULT = R"JSON({ + static constexpr auto kResult = R"JSON({ "result": { "index": 1 }, "forwarded": true })JSON"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "index": 1 }, @@ -367,31 +367,31 @@ TEST_F(WebRPCServerHandlerTest, WsForwardedPath) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsForwardedErrorPath) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99 })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); // Note: forwarding always goes thru WS API - static constexpr auto kRESULT = R"JSON({ + static constexpr auto kResult = R"JSON({ "error": "error", "error_code": 123, "error_message": "error message", @@ -401,7 +401,7 @@ TEST_F(WebRPCServerHandlerTest, WsForwardedErrorPath) })JSON"; // WS error responses, unlike their successful counterpart, contain everything on top level // without "result" - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "error": "error", "error_code": 123, "error_message": "error message", @@ -418,23 +418,23 @@ TEST_F(WebRPCServerHandlerTest, WsForwardedErrorPath) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); // Forwarded errors counted as successful: EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPErrorPath) { - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "error": "invalidParams", "error_code": 31, @@ -458,9 +458,9 @@ TEST_F(WebRPCServerHandlerTest, HTTPErrorPath) ] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kREQUEST_JSON = R"JSON({ + static constexpr auto kRequestJson = R"JSON({ "method": "ledger", "params": [ { @@ -471,7 +471,7 @@ TEST_F(WebRPCServerHandlerTest, HTTPErrorPath) EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL( - dosguard, request(session->clientIp(), boost::json::parse(kREQUEST_JSON).as_object()) + dosguard, request(session->clientIp(), boost::json::parse(kRequestJson).as_object()) ) .WillOnce(testing::Return(true)); @@ -486,14 +486,14 @@ TEST_F(WebRPCServerHandlerTest, HTTPErrorPath) EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST_JSON, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequestJson, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsErrorPath) { session->upgraded = true; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "id": "123", "error": "invalidParams", "error_code": 31, @@ -515,9 +515,9 @@ TEST_F(WebRPCServerHandlerTest, WsErrorPath) ] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kREQUEST_JSON = R"JSON({ + static constexpr auto kRequestJson = R"JSON({ "command": "ledger", "ledger_index": "xx", "id": "123", @@ -526,7 +526,7 @@ TEST_F(WebRPCServerHandlerTest, WsErrorPath) EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL( - dosguard, request(session->clientIp(), boost::json::parse(kREQUEST_JSON).as_object()) + dosguard, request(session->clientIp(), boost::json::parse(kRequestJson).as_object()) ) .WillOnce(testing::Return(true)); @@ -541,18 +541,18 @@ TEST_F(WebRPCServerHandlerTest, WsErrorPath) EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); - (*handler)(kREQUEST_JSON, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequestJson, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPNotReady) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "error": "notReady", "error_code": 13, @@ -567,25 +567,25 @@ TEST_F(WebRPCServerHandlerTest, HTTPNotReady) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyNotReady).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsNotReady) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99 })JSON"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "error": "notReady", "error_code": 13, "error_message": "Not ready to handle this request.", @@ -599,22 +599,22 @@ TEST_F(WebRPCServerHandlerTest, WsNotReady) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyNotReady).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPBadSyntaxWhenRequestSubscribe) { - static constexpr auto kREQUEST = R"JSON({"method": "subscribe"})JSON"; + static constexpr auto kRequest = R"JSON({"method": "subscribe"})JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "error": "badSyntax", "error_code": 1, @@ -633,75 +633,75 @@ TEST_F(WebRPCServerHandlerTest, HTTPBadSyntaxWhenRequestSubscribe) EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPMissingCommand) { - static constexpr auto kREQUEST = R"JSON({"method2": "server_info"})JSON"; + static constexpr auto kRequest = R"JSON({"method2": "server_info"})JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = "Null method"; + static constexpr auto kResponse = "Null method"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL(dosguard, request(session->clientIp(), testing::_)).WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(session->message, kRESPONSE); + (*handler)(kRequest, session); + EXPECT_EQ(session->message, kResponse); EXPECT_EQ(session->lastStatus, boost::beast::http::status::bad_request); } TEST_F(WebRPCServerHandlerTest, HTTPCommandNotString) { - static constexpr auto kREQUEST = R"JSON({"method": 1})JSON"; + static constexpr auto kRequest = R"JSON({"method": 1})JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = "method is not string"; + static constexpr auto kResponse = "method is not string"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL(dosguard, request(session->clientIp(), testing::_)).WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(session->message, kRESPONSE); + (*handler)(kRequest, session); + EXPECT_EQ(session->message, kResponse); EXPECT_EQ(session->lastStatus, boost::beast::http::status::bad_request); } TEST_F(WebRPCServerHandlerTest, HTTPCommandIsEmpty) { - static constexpr auto kREQUEST = R"JSON({"method": ""})JSON"; + static constexpr auto kRequest = R"JSON({"method": ""})JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = "method is empty"; + static constexpr auto kResponse = "method is empty"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL(dosguard, request(session->clientIp(), testing::_)).WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(session->message, kRESPONSE); + (*handler)(kRequest, session); + EXPECT_EQ(session->message, kResponse); EXPECT_EQ(session->lastStatus, boost::beast::http::status::bad_request); } TEST_F(WebRPCServerHandlerTest, WsMissingCommand) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command2": "server_info", "id": 99 })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "error": "missingCommand", "error_code": 6001, "error_message": "Method/Command is not specified or is not a string.", @@ -715,22 +715,22 @@ TEST_F(WebRPCServerHandlerTest, WsMissingCommand) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPParamsUnparsableNotArray) { - static constexpr auto kRESPONSE = "params unparsable"; + static constexpr auto kResponse = "params unparsable"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kREQUEST_JSON = R"JSON({ + static constexpr auto kRequestJson = R"JSON({ "method": "ledger", "params": "wrong" })JSON"; @@ -740,18 +740,18 @@ TEST_F(WebRPCServerHandlerTest, HTTPParamsUnparsableNotArray) EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST_JSON, session); - EXPECT_EQ(session->message, kRESPONSE); + (*handler)(kRequestJson, session); + EXPECT_EQ(session->message, kResponse); EXPECT_EQ(session->lastStatus, boost::beast::http::status::bad_request); } TEST_F(WebRPCServerHandlerTest, HTTPParamsUnparsableArrayWithDigit) { - static constexpr auto kRESPONSE = "params unparsable"; + static constexpr auto kResponse = "params unparsable"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kREQUEST_JSON = R"JSON({ + static constexpr auto kRequestJson = R"JSON({ "method": "ledger", "params": [1] })JSON"; @@ -761,14 +761,14 @@ TEST_F(WebRPCServerHandlerTest, HTTPParamsUnparsableArrayWithDigit) EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST_JSON, session); - EXPECT_EQ(session->message, kRESPONSE); + (*handler)(kRequestJson, session); + EXPECT_EQ(session->message, kResponse); EXPECT_EQ(session->lastStatus, boost::beast::http::status::bad_request); } TEST_F(WebRPCServerHandlerTest, HTTPInternalError) { - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "result": { "error": "internal", "error_code": 73, @@ -782,16 +782,16 @@ TEST_F(WebRPCServerHandlerTest, HTTPInternalError) } })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kREQUEST_JSON = R"JSON({ + static constexpr auto kRequestJson = R"JSON({ "method": "ledger", "params": [{}] })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL( - dosguard, request(session->clientIp(), boost::json::parse(kREQUEST_JSON).as_object()) + dosguard, request(session->clientIp(), boost::json::parse(kRequestJson).as_object()) ) .WillOnce(testing::Return(true)); @@ -800,15 +800,15 @@ TEST_F(WebRPCServerHandlerTest, HTTPInternalError) .Times(1) .WillOnce(testing::Throw(std::runtime_error("MyError"))); - (*handler)(kREQUEST_JSON, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequestJson, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsInternalError) { session->upgraded = true; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResponse = R"JSON({ "error": "internal", "error_code": 73, "error_message": "Internal error.", @@ -821,16 +821,16 @@ TEST_F(WebRPCServerHandlerTest, WsInternalError) } })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kREQUEST_JSON = R"JSON({ + static constexpr auto kRequestJson = R"JSON({ "command": "ledger", "id": "123" })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL( - dosguard, request(session->clientIp(), boost::json::parse(kREQUEST_JSON).as_object()) + dosguard, request(session->clientIp(), boost::json::parse(kRequestJson).as_object()) ) .WillOnce(testing::Return(true)); @@ -839,21 +839,21 @@ TEST_F(WebRPCServerHandlerTest, WsInternalError) .Times(1) .WillOnce(testing::Throw(std::runtime_error("MyError"))); - (*handler)(kREQUEST_JSON, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequestJson, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPOutDated) { - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESULT = "{}"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResult = "{}"; + static constexpr auto kResponse = R"JSON({ "result": { "status": "success" }, @@ -870,32 +870,32 @@ TEST_F(WebRPCServerHandlerTest, HTTPOutDated) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(61)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsOutdated) { session->upgraded = true; - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99 })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESULT = "{}"; - static constexpr auto kRESPONSE = R"JSON({ + static constexpr auto kResult = "{}"; + static constexpr auto kResponse = R"JSON({ "result": {}, "id": 99, "status": "success", @@ -913,17 +913,17 @@ TEST_F(WebRPCServerHandlerTest, WsOutdated) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) - .WillOnce(testing::Return(rpc::Result{boost::json::parse(kRESULT).as_object()})); + .WillOnce(testing::Return(rpc::Result{boost::json::parse(kResult).as_object()})); EXPECT_CALL(*rpcEngine, notifyComplete("server_info", testing::_)).Times(1); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(61)); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, WsTooBusy) @@ -934,14 +934,14 @@ TEST_F(WebRPCServerHandlerTest, WsTooBusy) auto localHandler = std::make_shared>( cfg, backend_, localRpcEngine, etl, dosguard ); - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "command": "server_info", "id": 99 })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = + static constexpr auto kResponse = R"JSON({ "error": "tooBusy", "error_code": 9, @@ -951,14 +951,14 @@ TEST_F(WebRPCServerHandlerTest, WsTooBusy) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*localRpcEngine, notifyTooBusy).Times(1); EXPECT_CALL(*localRpcEngine, post).WillOnce(testing::Return(false)); - (*localHandler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*localHandler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPTooBusy) @@ -967,14 +967,14 @@ TEST_F(WebRPCServerHandlerTest, HTTPTooBusy) auto localHandler = std::make_shared>( cfg, backend_, localRpcEngine, etl, dosguard ); - static constexpr auto kREQUEST = R"JSON({ + static constexpr auto kRequest = R"JSON({ "method": "server_info", "params": [{}] })JSON"; - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); - static constexpr auto kRESPONSE = + static constexpr auto kResponse = R"JSON({ "error": "tooBusy", "error_code": 9, @@ -984,35 +984,35 @@ TEST_F(WebRPCServerHandlerTest, HTTPTooBusy) })JSON"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); - EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kREQUEST).as_object())) + EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(kRequest).as_object())) .WillOnce(testing::Return(true)); EXPECT_CALL(*localRpcEngine, notifyTooBusy).Times(1); EXPECT_CALL(*localRpcEngine, post).WillOnce(testing::Return(false)); - (*localHandler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*localHandler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } TEST_F(WebRPCServerHandlerTest, HTTPRequestNotJson) { - static constexpr auto kREQUEST = "not json"; - static constexpr auto kRESPONSE_PREFIX = "Unable to parse JSON from the request"; + static constexpr auto kRequest = "not json"; + static constexpr auto kResponsePrefix = "Unable to parse JSON from the request"; EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_THAT(session->message, testing::StartsWith(kRESPONSE_PREFIX)); + (*handler)(kRequest, session); + EXPECT_THAT(session->message, testing::StartsWith(kResponsePrefix)); EXPECT_EQ(session->lastStatus, boost::beast::http::status::bad_request); } TEST_F(WebRPCServerHandlerTest, WsRequestNotJson) { session->upgraded = true; - static constexpr auto kREQUEST = "not json"; - static constexpr auto kRESPONSE = + static constexpr auto kRequest = "not json"; + static constexpr auto kResponse = R"JSON({ "error": "badSyntax", "error_code": 1, @@ -1025,8 +1025,8 @@ TEST_F(WebRPCServerHandlerTest, WsRequestNotJson) EXPECT_CALL(*rpcEngine, notifyBadSyntax).Times(1); - (*handler)(kREQUEST, session); - EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kRESPONSE)); + (*handler)(kRequest, session); + EXPECT_EQ(boost::json::parse(session->message), boost::json::parse(kResponse)); } struct InvalidAPIVersionTestBundle { @@ -1047,12 +1047,12 @@ generateInvalidVersions() {.testName = "v0", .version = "0", .wsMessage = fmt::format( - "Requested API version is lower than minimum supported ({})", rpc::kAPI_VERSION_MIN + "Requested API version is lower than minimum supported ({})", rpc::kApiVersionMin )}, {.testName = "v4", .version = "4", .wsMessage = fmt::format( - "Requested API version is higher than maximum supported ({})", rpc::kAPI_VERSION_MAX + "Requested API version is higher than maximum supported ({})", rpc::kApiVersionMax )}, {.testName = "null", .version = "null", .wsMessage = "API version must be an integer"}, {.testName = "str", .version = "\"bogus\"", .wsMessage = "API version must be an integer"}, @@ -1065,7 +1065,7 @@ INSTANTIATE_TEST_CASE_P( WebRPCServerHandlerAPIVersionGroup, WebRPCServerHandlerInvalidAPIVersionParamTest, testing::ValuesIn(generateInvalidVersions()), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_P(WebRPCServerHandlerInvalidAPIVersionParamTest, HTTPInvalidAPIVersion) @@ -1080,7 +1080,7 @@ TEST_P(WebRPCServerHandlerInvalidAPIVersionParamTest, HTTPInvalidAPIVersion) GetParam().version ); - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(request).as_object())) @@ -1104,7 +1104,7 @@ TEST_P(WebRPCServerHandlerInvalidAPIVersionParamTest, WSInvalidAPIVersion) GetParam().version ); - backend_->setRange(kMIN_SEQ, kMAX_SEQ); + backend_->setRange(kMinSeq, kMaxSeq); EXPECT_CALL(dosguard, isOk(session->clientIp())).WillOnce(testing::Return(true)); EXPECT_CALL(dosguard, request(session->clientIp(), boost::json::parse(request).as_object())) diff --git a/tests/unit/web/ServerTests.cpp b/tests/unit/web/ServerTests.cpp index ad389502f..326b2be7f 100644 --- a/tests/unit/web/ServerTests.cpp +++ b/tests/unit/web/ServerTests.cpp @@ -518,7 +518,7 @@ jsonServerConfigWithNoSpecifiedAdmin(uint32_t const port) } // get this value from online sha256 generator -constexpr auto kSECRET_SHA256 = "2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b"; +constexpr auto kSecretShA256 = "2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b"; } // namespace @@ -630,7 +630,7 @@ INSTANTIATE_TEST_CASE_P( }, WebServerAdminTestParams{ .config = jsonServerConfigWithAdminPassword(tests::util::generateFreePort()), - .headers = {WebHeader(http::field::authorization, kSECRET_SHA256)}, + .headers = {WebHeader(http::field::authorization, kSecretShA256)}, .expectedResponse = "user" }, WebServerAdminTestParams{ @@ -639,8 +639,8 @@ INSTANTIATE_TEST_CASE_P( http::field::authorization, fmt::format( "{}{}", - PasswordAdminVerificationStrategy::kPASSWORD_PREFIX, - kSECRET_SHA256 + PasswordAdminVerificationStrategy::kPasswordPrefix, + kSecretShA256 ) )}, .expectedResponse = "admin" @@ -649,7 +649,7 @@ INSTANTIATE_TEST_CASE_P( .config = jsonServerConfigWithBothAdminPasswordAndLocalAdminFalse( tests::util::generateFreePort() ), - .headers = {WebHeader(http::field::authorization, kSECRET_SHA256)}, + .headers = {WebHeader(http::field::authorization, kSecretShA256)}, .expectedResponse = "user" }, WebServerAdminTestParams{ @@ -660,8 +660,8 @@ INSTANTIATE_TEST_CASE_P( http::field::authorization, fmt::format( "{}{}", - PasswordAdminVerificationStrategy::kPASSWORD_PREFIX, - kSECRET_SHA256 + PasswordAdminVerificationStrategy::kPasswordPrefix, + kSecretShA256 ) )}, .expectedResponse = "admin" @@ -672,8 +672,8 @@ INSTANTIATE_TEST_CASE_P( http::field::authentication_info, fmt::format( "{}{}", - PasswordAdminVerificationStrategy::kPASSWORD_PREFIX, - kSECRET_SHA256 + PasswordAdminVerificationStrategy::kPasswordPrefix, + kSecretShA256 ) )}, .expectedResponse = "user" @@ -789,7 +789,7 @@ TEST_F(WebServerPrometheusDisabledTest, rejectedIfPrometheusIsDisabled) "/metrics", {WebHeader( http::field::authorization, - fmt::format("{}{}", PasswordAdminVerificationStrategy::kPASSWORD_PREFIX, kSECRET_SHA256) + fmt::format("{}{}", PasswordAdminVerificationStrategy::kPasswordPrefix, kSecretShA256) )} ); EXPECT_EQ(res, "Prometheus is disabled in clio config"); @@ -814,7 +814,7 @@ TEST_F(WebServerPrometheusTest, validResponse) "/metrics", {WebHeader( http::field::authorization, - fmt::format("{}{}", PasswordAdminVerificationStrategy::kPASSWORD_PREFIX, kSECRET_SHA256) + fmt::format("{}{}", PasswordAdminVerificationStrategy::kPasswordPrefix, kSecretShA256) )} ); EXPECT_EQ(res, "# TYPE test_counter counter\ntest_counter 1\n\n"); diff --git a/tests/unit/web/dosguard/DOSGuardTests.cpp b/tests/unit/web/dosguard/DOSGuardTests.cpp index edf362051..d1586edaf 100644 --- a/tests/unit/web/dosguard/DOSGuardTests.cpp +++ b/tests/unit/web/dosguard/DOSGuardTests.cpp @@ -21,7 +21,7 @@ using namespace util::config; using namespace web::dosguard; struct DOSGuardTest : public virtual ::testing::Test { - static constexpr auto kJSON_DATA = R"JSON({ + static constexpr auto kJsonData = R"JSON({ "dos_guard": { "max_fetches": 100, "max_connections": 2, diff --git a/tests/unit/web/dosguard/IntervalSweepHandlerTests.cpp b/tests/unit/web/dosguard/IntervalSweepHandlerTests.cpp index 714834c93..15f770286 100644 --- a/tests/unit/web/dosguard/IntervalSweepHandlerTests.cpp +++ b/tests/unit/web/dosguard/IntervalSweepHandlerTests.cpp @@ -15,7 +15,7 @@ using namespace util::config; struct IntervalSweepHandlerTest : SyncAsioContextTest { protected: - static constexpr auto kJSON_DATA = R"JSON( + static constexpr auto kJsonData = R"JSON( { "dos_guard": { "sweep_interval": 0 diff --git a/tests/unit/web/dosguard/WhitelistHandlerTests.cpp b/tests/unit/web/dosguard/WhitelistHandlerTests.cpp index c3d3e8ed7..5a56c6d8a 100644 --- a/tests/unit/web/dosguard/WhitelistHandlerTests.cpp +++ b/tests/unit/web/dosguard/WhitelistHandlerTests.cpp @@ -42,7 +42,7 @@ TEST_F(WhitelistHandlerTest, TestWhiteListIPV4) testing::StrictMock mockResolver; - static constexpr auto kJSON_DATA_IP_V4 = R"JSON( + static constexpr auto kJsonDataIpV4 = R"JSON( { "dos_guard": { "whitelist": [ @@ -61,7 +61,7 @@ TEST_F(WhitelistHandlerTest, TestWhiteListIPV4) }); ClioConfigDefinition const cfg{ - getParseWhitelistHandlerConfig(boost::json::parse(kJSON_DATA_IP_V4)) + getParseWhitelistHandlerConfig(boost::json::parse(kJsonDataIpV4)) }; auto const result = WhitelistHandler::create(cfg, mockResolver); ASSERT_TRUE(result.has_value()); @@ -75,7 +75,7 @@ TEST_F(WhitelistHandlerTest, TestWhiteListIPV4) TEST_F(WhitelistHandlerTest, TestWhiteListResolvesHostname) { - static constexpr auto kJSON_DATA_IP_V4 = R"JSON( + static constexpr auto kJsonDataIpV4 = R"JSON( { "dos_guard": { "whitelist": [ @@ -87,7 +87,7 @@ TEST_F(WhitelistHandlerTest, TestWhiteListResolvesHostname) )JSON"; ClioConfigDefinition const cfg{ - getParseWhitelistHandlerConfig(boost::json::parse(kJSON_DATA_IP_V4)) + getParseWhitelistHandlerConfig(boost::json::parse(kJsonDataIpV4)) }; auto const result = WhitelistHandler::create(cfg); ASSERT_TRUE(result.has_value()); @@ -101,7 +101,7 @@ TEST_F(WhitelistHandlerTest, TestWhiteListResolvesHostname) TEST_F(WhitelistHandlerTest, TestWhiteListIPV6) { - static constexpr auto kJSON_DATA_IP_V6 = R"JSON( + static constexpr auto kJsonDataIpV6 = R"JSON( { "dos_guard": { "whitelist": [ @@ -113,7 +113,7 @@ TEST_F(WhitelistHandlerTest, TestWhiteListIPV6) )JSON"; ClioConfigDefinition const cfg{ - getParseWhitelistHandlerConfig(boost::json::parse(kJSON_DATA_IP_V6)) + getParseWhitelistHandlerConfig(boost::json::parse(kJsonDataIpV6)) }; auto const result = WhitelistHandler::create(cfg); ASSERT_TRUE(result.has_value()); @@ -162,7 +162,7 @@ TEST_F(WhitelistHandlerTest, CreateWithInvalidIPFails) MOCK_METHOD(std::vector, resolve, (std::string_view)); }; - static constexpr auto kJSON = R"JSON( + static constexpr auto kJson = R"JSON( { "dos_guard": { "whitelist": ["not-an-ip"] @@ -176,7 +176,7 @@ TEST_F(WhitelistHandlerTest, CreateWithInvalidIPFails) return {std::string{hostname}}; }); - ClioConfigDefinition const cfg{getParseWhitelistHandlerConfig(boost::json::parse(kJSON))}; + ClioConfigDefinition const cfg{getParseWhitelistHandlerConfig(boost::json::parse(kJson))}; auto const result = WhitelistHandler::create(cfg, mockResolver); ASSERT_FALSE(result.has_value()); EXPECT_THAT(result.error(), testing::HasSubstr("not-an-ip")); diff --git a/tests/unit/web/impl/ErrorHandlingTests.cpp b/tests/unit/web/impl/ErrorHandlingTests.cpp index b85b8754f..56fc934cb 100644 --- a/tests/unit/web/impl/ErrorHandlingTests.cpp +++ b/tests/unit/web/impl/ErrorHandlingTests.cpp @@ -102,7 +102,7 @@ INSTANTIATE_TEST_CASE_P( {"request", {{"id", 1}, {"api_version", 2}}}}}} }} ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct ErrorHandlingSendErrorTestBundle { @@ -182,7 +182,7 @@ INSTANTIATE_TEST_CASE_P( boost::beast::http::status::bad_request }, }), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_F(ErrorHandlingTests, sendInternalError) diff --git a/tests/unit/web/ng/RequestTests.cpp b/tests/unit/web/ng/RequestTests.cpp index 7bce2bd36..7cbe808c5 100644 --- a/tests/unit/web/ng/RequestTests.cpp +++ b/tests/unit/web/ng/RequestTests.cpp @@ -16,9 +16,9 @@ using namespace web::ng; namespace http = boost::beast::http; struct RequestTest : public ::testing::Test { - static Request::HttpHeaders const kHEADERS; + static Request::HttpHeaders const kHeaders; }; -Request::HttpHeaders const RequestTest::kHEADERS = {}; +Request::HttpHeaders const RequestTest::kHeaders = {}; struct RequestMethodTestBundle { std::string testName; @@ -49,7 +49,7 @@ INSTANTIATE_TEST_SUITE_P( }, RequestMethodTestBundle{ .testName = "WebSocket", - .request = Request{"websocket message", RequestTest::kHEADERS}, + .request = Request{"websocket message", RequestTest::kHeaders}, .expectedMethod = Request::Method::Websocket, }, RequestMethodTestBundle{ @@ -58,7 +58,7 @@ INSTANTIATE_TEST_SUITE_P( .expectedMethod = Request::Method::Unsupported, } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct RequestIsHttpTestBundle { @@ -85,11 +85,11 @@ INSTANTIATE_TEST_SUITE_P( }, RequestIsHttpTestBundle{ .testName = "WebSocketRequest", - .request = Request{"websocket message", RequestTest::kHEADERS}, + .request = Request{"websocket message", RequestTest::kHeaders}, .expectedIsHttp = false, } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct RequestAsHttpRequestTest : RequestTest {}; @@ -109,7 +109,7 @@ TEST_F(RequestAsHttpRequestTest, HttpRequest) TEST_F(RequestAsHttpRequestTest, WebSocketRequest) { - Request const request{"websocket message", RequestTest::kHEADERS}; + Request const request{"websocket message", RequestTest::kHeaders}; auto const maybeHttpRequest = request.asHttpRequest(); EXPECT_FALSE(maybeHttpRequest.has_value()); } @@ -127,7 +127,7 @@ TEST_F(RequestMessageTest, HttpRequest) TEST_F(RequestMessageTest, WebSocketRequest) { std::string const message = "websocket message"; - Request const request{message, RequestTest::kHEADERS}; + Request const request{message, RequestTest::kHeaders}; EXPECT_EQ(request.message(), message); } @@ -156,11 +156,11 @@ INSTANTIATE_TEST_SUITE_P( }, RequestTargetTestBundle{ .testName = "WebSocketRequest", - .request = Request{"websocket message", RequestTest::kHEADERS}, + .request = Request{"websocket message", RequestTest::kHeaders}, .expectedTarget = std::nullopt, } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct RequestHttpHeadersTest : RequestTest { diff --git a/tests/unit/web/ng/ServerTests.cpp b/tests/unit/web/ng/ServerTests.cpp index 36cd6a260..7eb57f611 100644 --- a/tests/unit/web/ng/ServerTests.cpp +++ b/tests/unit/web/ng/ServerTests.cpp @@ -140,7 +140,7 @@ INSTANTIATE_TEST_CASE_P( true } ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct ServerTest : util::prometheus::WithPrometheus, SyncAsioContextTest { @@ -567,7 +567,7 @@ INSTANTIATE_TEST_SUITE_P( ServerHttpTestBundle{"GET", http::verb::get}, ServerHttpTestBundle{"POST", http::verb::post} ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_F(ServerTest, WsClientDisconnects) diff --git a/tests/unit/web/ng/impl/ConnectionHandlerTests.cpp b/tests/unit/web/ng/impl/ConnectionHandlerTests.cpp index 31d8f5b4f..fa28f9a8a 100644 --- a/tests/unit/web/ng/impl/ConnectionHandlerTests.cpp +++ b/tests/unit/web/ng/impl/ConnectionHandlerTests.cpp @@ -149,9 +149,7 @@ TEST_F(ConnectionHandlerSequentialProcessingTest, ReceiveError_CloseConnection) .WillOnce(Return(makeError(boost::asio::error::timed_out))); EXPECT_CALL( *mockHttpConnection, - setTimeout( - std::chrono::steady_clock::duration{ConnectionHandler::kCLOSE_CONNECTION_TIMEOUT} - ) + setTimeout(std::chrono::steady_clock::duration{ConnectionHandler::kCloseConnectionTimeout}) ); EXPECT_CALL(*mockHttpConnection, close); EXPECT_CALL(onDisconnectMock, Call) @@ -424,9 +422,7 @@ TEST_F(ConnectionHandlerSequentialProcessingTest, SubscriptionContextIsNullForHt EXPECT_CALL( *mockHttpConnection, - setTimeout( - std::chrono::steady_clock::duration{ConnectionHandler::kCLOSE_CONNECTION_TIMEOUT} - ) + setTimeout(std::chrono::steady_clock::duration{ConnectionHandler::kCloseConnectionTimeout}) ); EXPECT_CALL(*mockHttpConnection, close); @@ -484,9 +480,7 @@ TEST_F(ConnectionHandlerSequentialProcessingTest, Receive_Handle_Send_Loop) EXPECT_CALL( *mockHttpConnection, - setTimeout( - std::chrono::steady_clock::duration{ConnectionHandler::kCLOSE_CONNECTION_TIMEOUT} - ) + setTimeout(std::chrono::steady_clock::duration{ConnectionHandler::kCloseConnectionTimeout}) ); EXPECT_CALL(*mockHttpConnection, close); @@ -759,9 +753,7 @@ TEST_F(ConnectionHandlerSequentialProcessingTest, Stop) EXPECT_CALL( *mockWsConnection, - setTimeout( - std::chrono::steady_clock::duration{ConnectionHandler::kCLOSE_CONNECTION_TIMEOUT} - ) + setTimeout(std::chrono::steady_clock::duration{ConnectionHandler::kCloseConnectionTimeout}) ); EXPECT_CALL(*mockWsConnection, close).WillOnce([&connectionClosed]() { connectionClosed = true; @@ -804,9 +796,7 @@ TEST_F(ConnectionHandlerSequentialProcessingTest, ProcessCalledAfterStop) EXPECT_CALL( *mockWsConnection, - setTimeout( - std::chrono::steady_clock::duration{ConnectionHandler::kCLOSE_CONNECTION_TIMEOUT} - ) + setTimeout(std::chrono::steady_clock::duration{ConnectionHandler::kCloseConnectionTimeout}) ); EXPECT_CALL(*mockWsConnection, close); @@ -816,12 +806,12 @@ TEST_F(ConnectionHandlerSequentialProcessingTest, ProcessCalledAfterStop) } struct ConnectionHandlerParallelProcessingTest : ConnectionHandlerTest { - static constexpr size_t kMAX_PARALLEL_REQUESTS = 3; + static constexpr size_t kMaxParallelRequests = 3; ConnectionHandlerParallelProcessingTest() : ConnectionHandlerTest( ProcessingPolicy::Parallel, - ConnectionHandlerParallelProcessingTest::kMAX_PARALLEL_REQUESTS + ConnectionHandlerParallelProcessingTest::kMaxParallelRequests ) { } diff --git a/tests/unit/web/ng/impl/ErrorHandlingTests.cpp b/tests/unit/web/ng/impl/ErrorHandlingTests.cpp index b01ff2d98..f301662eb 100644 --- a/tests/unit/web/ng/impl/ErrorHandlingTests.cpp +++ b/tests/unit/web/ng/impl/ErrorHandlingTests.cpp @@ -32,8 +32,8 @@ struct NgErrorHandlingTests : public virtual ::testing::Test { http::request{http::verb::post, "/", 11, body.value_or("")} }; } - static Request::HttpHeaders const kHEADERS; - return Request{body.value_or(""), kHEADERS}; + static Request::HttpHeaders const kHeaders; + return Request{body.value_or(""), kHeaders}; } }; @@ -122,7 +122,7 @@ INSTANTIATE_TEST_CASE_P( boost::beast::http::status::bad_request }, }), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct NgErrorHandlingMakeInternalErrorTestBundle { @@ -219,7 +219,7 @@ INSTANTIATE_TEST_CASE_P( {"request", {{"id", 1}, {"api_version", 2}}}}}} }} ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); TEST_F(NgErrorHandlingTests, MakeNotReadyError) @@ -340,5 +340,5 @@ INSTANTIATE_TEST_CASE_P( R"JSON({"result":{"error":"internal","error_code":73,"error_message":"Internal error.","status":"error","type":"response","id":1,"request":{"id":1,"api_version":2}}})JSON" }} ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); diff --git a/tests/unit/web/ng/impl/ServerSslContextTests.cpp b/tests/unit/web/ng/impl/ServerSslContextTests.cpp index fb324c563..78fe4b479 100644 --- a/tests/unit/web/ng/impl/ServerSslContextTests.cpp +++ b/tests/unit/web/ng/impl/ServerSslContextTests.cpp @@ -101,7 +101,7 @@ INSTANTIATE_TEST_SUITE_P( .expectContext = false }} ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator ); struct MakeServerSslContextFromConfigRealFilesTest : testing::Test {}; @@ -178,5 +178,5 @@ INSTANTIATE_TEST_SUITE_P( .expectedSuccess = true }} ), - tests::util::kNAME_GENERATOR + tests::util::kNameGenerator );