diff --git a/examples/README.md b/examples/README.md index efa8a56de..322d795dd 100644 --- a/examples/README.md +++ b/examples/README.md @@ -67,10 +67,10 @@ using namespace score::kvs; int main() { auto open_res = KvsBuilder(InstanceId(0)) - .need_defaults_flag(OpenNeedDefaults::Optional) - .need_kvs_flag(OpenNeedKvs::Optional) - .dir("./data_folder/") - .build(); + .Defaults(KvsDefaults::kOptional) + .KvsLoad(KvsLoad::kOptional) + .WorkingDir("./data_folder/") + .Build(); if (!open_res) { std::cerr << "Failed to open KVS" << std::endl; @@ -79,39 +79,39 @@ int main() Kvs kvs = std::move(open_res.value()); // Set a key-value pair; errors shall be handled by the application (see safety manual) - if (!kvs.set_value("username", KvsValue("alice"))) + if (!kvs.SetValue("username", KvsValue("alice"))) { std::cerr << "Failed to set value" << std::endl; return 1; } - // Read a stored value (returns KeyNotFound if no value is stored for the key) - auto get_res = kvs.get_value("username"); - if (get_res && get_res.value().getType() == KvsValue::Type::String) + // Read a stored value (returns kKeyNotFound if no value is stored for the key) + auto get_res = kvs.GetValue("username"); + if (get_res && get_res.value().GetType() == KvsValue::Type::kString) { - std::cout << "username: " << std::get(get_res.value().getValue()) << std::endl; + std::cout << "username: " << std::get(get_res.value().GetValue()) << std::endl; } // Read a default value - auto default_res = kvs.get_default_value("language"); + auto default_res = kvs.GetDefaultValue("language"); // Check if a value is stored for a key - if (kvs.key_exists("username").value_or(false)) + if (kvs.KeyExists("username").value_or(false)) { std::cout << "username exists" << std::endl; } // Remove a key - if (!kvs.remove_key("username")) + if (!kvs.RemoveKey("username")) { std::cerr << "Failed to remove key" << std::endl; } // List all keys with a stored value (defaults are not listed) - auto keys_res = kvs.get_all_keys(); + auto keys_res = kvs.GetAllKeys(); // Write the values to the storage - if (!kvs.flush()) + if (!kvs.Flush()) { std::cerr << "Failed to flush KVS" << std::endl; return 1; diff --git a/score/kvs/BUILD b/score/kvs/BUILD index d9b68804f..33bfbc79a 100644 --- a/score/kvs/BUILD +++ b/score/kvs/BUILD @@ -78,6 +78,7 @@ cc_test( size = "small", srcs = [ "kvs_builder_test.cpp", + "kvs_deprecated_api_test.cpp", "kvs_error_test.cpp", "kvs_general_test.cpp", "kvs_general_test.h", @@ -98,6 +99,7 @@ cc_test( "@score_baselibs//score/os:stat", "@score_baselibs//score/os/mocklib:fcntl_mock", "@score_baselibs//score/os/mocklib:stat_mock", + "@score_baselibs//score/quality/compiler_warnings", "@score_baselibs//score/result", ], ) diff --git a/score/kvs/error.cpp b/score/kvs/error.cpp index 5fbffea9f..ca8d5261f 100644 --- a/score/kvs/error.cpp +++ b/score/kvs/error.cpp @@ -20,49 +20,49 @@ std::string_view KvsErrorDomain::MessageFor(const score::result::ErrorCode& code { switch (static_cast(code)) { - case ErrorCode::UnmappedError: + case ErrorCode::kUnmappedError: return "Error that was not yet mapped"; - case ErrorCode::FileNotFound: + case ErrorCode::kFileNotFound: return "File not found"; - case ErrorCode::KvsFileReadError: + case ErrorCode::kKvsFileReadError: return "KVS file read error"; - case ErrorCode::KvsHashFileReadError: + case ErrorCode::kKvsHashFileReadError: return "KVS hash file read error"; - case ErrorCode::JsonParserError: + case ErrorCode::kJsonParserError: return "JSON parser error"; - case ErrorCode::JsonGeneratorError: + case ErrorCode::kJsonGeneratorError: return "JSON generator error"; - case ErrorCode::PhysicalStorageFailure: + case ErrorCode::kPhysicalStorageFailure: return "Physical storage failure"; - case ErrorCode::IntegrityCorrupted: + case ErrorCode::kIntegrityCorrupted: return "Integrity corrupted"; - case ErrorCode::ValidationFailed: + case ErrorCode::kValidationFailed: return "Validation failed"; - case ErrorCode::EncryptionFailed: + case ErrorCode::kEncryptionFailed: return "Encryption failed"; - case ErrorCode::ResourceBusy: + case ErrorCode::kResourceBusy: return "Resource is busy"; - case ErrorCode::OutOfStorageSpace: + case ErrorCode::kOutOfStorageSpace: return "Out of storage space"; - case ErrorCode::QuotaExceeded: + case ErrorCode::kQuotaExceeded: return "Quota exceeded"; - case ErrorCode::AuthenticationFailed: + case ErrorCode::kAuthenticationFailed: return "Authentication failed"; - case ErrorCode::KeyNotFound: + case ErrorCode::kKeyNotFound: return "Key not found"; - case ErrorCode::KeyDefaultNotFound: + case ErrorCode::kKeyDefaultNotFound: return "Key default value not found"; - case ErrorCode::SerializationFailed: + case ErrorCode::kSerializationFailed: return "Serialization failed"; - case ErrorCode::InvalidSnapshotId: + case ErrorCode::kInvalidSnapshotId: return "Invalid snapshot ID"; - case ErrorCode::ConversionFailed: + case ErrorCode::kConversionFailed: return "Conversion failed"; - case ErrorCode::MutexLockFailed: + case ErrorCode::kMutexLockFailed: return "Mutex failed"; - case ErrorCode::InvalidValueType: + case ErrorCode::kInvalidValueType: return "Invalid value type"; - case ErrorCode::InvalidKey: + case ErrorCode::kInvalidKey: return "Key is not valid"; default: return "Unknown Error!"; @@ -71,12 +71,12 @@ std::string_view KvsErrorDomain::MessageFor(const score::result::ErrorCode& code namespace { -constexpr KvsErrorDomain kvs_error_domain; +constexpr KvsErrorDomain kKvsErrorDomain; } score::result::Error MakeError(const ErrorCode code, const std::string_view user_message) noexcept { - return {static_cast(code), kvs_error_domain, user_message}; + return {static_cast(code), kKvsErrorDomain, user_message}; } } // namespace score::kvs diff --git a/score/kvs/error.h b/score/kvs/error.h index ab07f5c91..20125f092 100644 --- a/score/kvs/error.h +++ b/score/kvs/error.h @@ -24,70 +24,116 @@ namespace score::kvs enum class ErrorCode : score::result::ErrorCode { /// Error that was not yet mapped. - UnmappedError, + kUnmappedError = 0, /// File not found. - FileNotFound, + kFileNotFound = 1, /// KVS file read error. - KvsFileReadError, + kKvsFileReadError = 2, /// KVS hash file read error. - KvsHashFileReadError, + kKvsHashFileReadError = 3, /// JSON parser error. - JsonParserError, + kJsonParserError = 4, /// JSON generator error. - JsonGeneratorError, + kJsonGeneratorError = 5, /// Physical storage failure. - PhysicalStorageFailure, + kPhysicalStorageFailure = 6, /// Integrity corrupted. - IntegrityCorrupted, + kIntegrityCorrupted = 7, /// Validation failed. - ValidationFailed, + kValidationFailed = 8, /// Encryption failed. - EncryptionFailed, + kEncryptionFailed = 9, /// Resource is busy. - ResourceBusy, + kResourceBusy = 10, /// Out of storage space. - OutOfStorageSpace, + kOutOfStorageSpace = 11, /// Quota exceeded. - QuotaExceeded, + kQuotaExceeded = 12, /// Authentication failed. - AuthenticationFailed, + kAuthenticationFailed = 13, /// Key not found. - KeyNotFound, + kKeyNotFound = 14, /// Key default value not found. - KeyDefaultNotFound, + kKeyDefaultNotFound = 15, /// Serialization failed. - SerializationFailed, + kSerializationFailed = 16, /// Invalid snapshot ID. - InvalidSnapshotId, + kInvalidSnapshotId = 17, /// Conversion failed. - ConversionFailed, + kConversionFailed = 18, /// Mutex failed. - MutexLockFailed, + kMutexLockFailed = 19, /// Invalid value type. - InvalidValueType, + kInvalidValueType = 20, /// Key is not valid. - InvalidKey, + kInvalidKey = 21, + + // Deprecated enumerators. + // Each one is an alias of its k-prefixed replacement and is removed in a future release. + UnmappedError [[deprecated("Use kUnmappedError instead. This name is removed in a future release.")]] = + kUnmappedError, + FileNotFound [[deprecated("Use kFileNotFound instead. This name is removed in a future release.")]] = kFileNotFound, + KvsFileReadError [[deprecated("Use kKvsFileReadError instead. This name is removed in a future release.")]] = + kKvsFileReadError, + KvsHashFileReadError + [[deprecated("Use kKvsHashFileReadError instead. This name is removed in a future release.")]] = + kKvsHashFileReadError, + JsonParserError [[deprecated("Use kJsonParserError instead. This name is removed in a future release.")]] = + kJsonParserError, + JsonGeneratorError [[deprecated("Use kJsonGeneratorError instead. This name is removed in a future release.")]] = + kJsonGeneratorError, + PhysicalStorageFailure + [[deprecated("Use kPhysicalStorageFailure instead. This name is removed in a future release.")]] = + kPhysicalStorageFailure, + IntegrityCorrupted [[deprecated("Use kIntegrityCorrupted instead. This name is removed in a future release.")]] = + kIntegrityCorrupted, + ValidationFailed [[deprecated("Use kValidationFailed instead. This name is removed in a future release.")]] = + kValidationFailed, + EncryptionFailed [[deprecated("Use kEncryptionFailed instead. This name is removed in a future release.")]] = + kEncryptionFailed, + ResourceBusy [[deprecated("Use kResourceBusy instead. This name is removed in a future release.")]] = kResourceBusy, + OutOfStorageSpace [[deprecated("Use kOutOfStorageSpace instead. This name is removed in a future release.")]] = + kOutOfStorageSpace, + QuotaExceeded [[deprecated("Use kQuotaExceeded instead. This name is removed in a future release.")]] = + kQuotaExceeded, + AuthenticationFailed + [[deprecated("Use kAuthenticationFailed instead. This name is removed in a future release.")]] = + kAuthenticationFailed, + KeyNotFound [[deprecated("Use kKeyNotFound instead. This name is removed in a future release.")]] = kKeyNotFound, + KeyDefaultNotFound [[deprecated("Use kKeyDefaultNotFound instead. This name is removed in a future release.")]] = + kKeyDefaultNotFound, + SerializationFailed [[deprecated("Use kSerializationFailed instead. This name is removed in a future release.")]] = + kSerializationFailed, + InvalidSnapshotId [[deprecated("Use kInvalidSnapshotId instead. This name is removed in a future release.")]] = + kInvalidSnapshotId, + ConversionFailed [[deprecated("Use kConversionFailed instead. This name is removed in a future release.")]] = + kConversionFailed, + MutexLockFailed [[deprecated("Use kMutexLockFailed instead. This name is removed in a future release.")]] = + kMutexLockFailed, + InvalidValueType [[deprecated("Use kInvalidValueType instead. This name is removed in a future release.")]] = + kInvalidValueType, + InvalidKey [[deprecated("Use kInvalidKey instead. This name is removed in a future release.")]] = kInvalidKey, }; /// @brief Error domain translating `ErrorCode` codes to human-readable messages. diff --git a/score/kvs/internal/kvs_helper.cpp b/score/kvs/internal/kvs_helper.cpp index 3db1b2380..78da82a50 100644 --- a/score/kvs/internal/kvs_helper.cpp +++ b/score/kvs/internal/kvs_helper.cpp @@ -17,10 +17,10 @@ namespace score::kvs { // Optimized version: processes data in blocks to reduce modulo operations. -uint32_t calculate_hash_adler32(const std::string& data) noexcept +uint32_t CalculateHashAdler32(const std::string& data) noexcept { - constexpr size_t ADLER32_NMAX = 5552; - constexpr uint32_t ADLER32_BASE = 65521; + constexpr size_t kAdler32Nmax = 5552; + constexpr uint32_t kAdler32Base = 65521; uint32_t a = 1; uint32_t b = 0; size_t len = data.size(); @@ -29,20 +29,20 @@ uint32_t calculate_hash_adler32(const std::string& data) noexcept // Process in blocks of 5552 bytes (as recommended for Adler-32). while (len > 0) { - const size_t tlen = len > ADLER32_NMAX ? ADLER32_NMAX : len; + const size_t tlen = len > kAdler32Nmax ? kAdler32Nmax : len; len -= tlen; for (size_t j = 0; j < tlen; ++j, ++i) { a += static_cast(data[i]); b += a; } - a %= ADLER32_BASE; - b %= ADLER32_BASE; + a %= kAdler32Base; + b %= kAdler32Base; } return (b << 16) | a; } -uint32_t parse_hash_adler32(std::istream& in) noexcept +uint32_t ParseHashAdler32(std::istream& in) noexcept { std::array buf{}; in.read(reinterpret_cast(buf.data()), buf.size()); @@ -52,7 +52,7 @@ uint32_t parse_hash_adler32(std::istream& in) noexcept return value; } -std::array get_hash_bytes_adler32(const uint32_t hash) noexcept +std::array GetHashBytesAdler32(const uint32_t hash) noexcept { std::array value = {static_cast((hash >> 24) & 0xFF), static_cast((hash >> 16) & 0xFF), @@ -61,149 +61,149 @@ std::array get_hash_bytes_adler32(const uint32_t hash) noexcept return value; } -std::array get_hash_bytes(const std::string& data) noexcept +std::array GetHashBytes(const std::string& data) noexcept { - const uint32_t hash = calculate_hash_adler32(data); - std::array value = get_hash_bytes_adler32(hash); + const uint32_t hash = CalculateHashAdler32(data); + std::array value = GetHashBytesAdler32(hash); return value; } -bool check_hash(const std::string& data_calculate, std::istream& data_parse) noexcept +bool CheckHash(const std::string& data_calculate, std::istream& data_parse) noexcept { - const uint32_t calculated_hash = calculate_hash_adler32(data_calculate); - const uint32_t parsed_hash = parse_hash_adler32(data_parse); + const uint32_t calculated_hash = CalculateHashAdler32(data_calculate); + const uint32_t parsed_hash = ParseHashAdler32(data_parse); return calculated_hash == parsed_hash; } -score::Result any_to_kvsvalue(const score::json::Any& any) noexcept +score::Result AnyToKvsValue(const score::json::Any& any) noexcept { const auto o = any.As(); if (!o.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } - const auto& objAny = o.value().get(); - const auto type = objAny.find("t"); - const auto value = objAny.find("v"); - if (type == objAny.end() || value == objAny.end()) + const auto& obj_any = o.value().get(); + const auto type = obj_any.find("t"); + const auto value = obj_any.find("v"); + if (type == obj_any.end() || value == obj_any.end()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } - const auto typeStr = type->second.As(); - if (!typeStr.has_value()) + const auto type_str = type->second.As(); + if (!type_str.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } - const std::string_view typeStrV = typeStr.value().get(); - const score::json::Any& valueAny = value->second; + const std::string_view type_str_view = type_str.value().get(); + const score::json::Any& value_any = value->second; - if (typeStrV == "i32") + if (type_str_view == "i32") { - const auto n = valueAny.As(); + const auto n = value_any.As(); if (!n.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(static_cast(n.value())); } - else if (typeStrV == "u32") + else if (type_str_view == "u32") { - const auto n = valueAny.As(); + const auto n = value_any.As(); if (!n.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(static_cast(n.value())); } - else if (typeStrV == "i64") + else if (type_str_view == "i64") { - const auto n = valueAny.As(); + const auto n = value_any.As(); if (!n.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(static_cast(n.value())); } - else if (typeStrV == "u64") + else if (type_str_view == "u64") { - const auto n = valueAny.As(); + const auto n = value_any.As(); if (!n.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(static_cast(n.value())); } - else if (typeStrV == "f64") + else if (type_str_view == "f64") { - const auto n = valueAny.As(); + const auto n = value_any.As(); if (!n.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(n.value()); } - else if (typeStrV == "bool") + else if (type_str_view == "bool") { - const auto b = valueAny.As(); + const auto b = value_any.As(); if (!b.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(b.value()); } - else if (typeStrV == "str") + else if (type_str_view == "str") { - const auto s = valueAny.As(); + const auto s = value_any.As(); if (!s.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(s.value().get()); } - else if (typeStrV == "null") + else if (type_str_view == "null") { - if (!valueAny.As().has_value()) + if (!value_any.As().has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } return KvsValue(nullptr); } - else if (typeStrV == "arr") + else if (type_str_view == "arr") { - const auto l = valueAny.As(); + const auto l = value_any.As(); if (!l.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } KvsValue::Array arr; for (const auto& elem : l.value().get()) { - auto conv = any_to_kvsvalue(elem); + auto conv = AnyToKvsValue(elem); if (!conv) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } arr.emplace_back(std::move(conv.value())); } return KvsValue(std::move(arr)); } - else if (typeStrV == "obj") + else if (type_str_view == "obj") { - const auto obj = valueAny.As(); + const auto obj = value_any.As(); if (!obj.has_value()) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } KvsValue::Object map; - for (const auto& [key, valAny] : obj.value().get()) + for (const auto& [key, val_any] : obj.value().get()) { - auto conv = any_to_kvsvalue(valAny); + auto conv = AnyToKvsValue(val_any); if (!conv) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } map.emplace_back(std::string(key.GetAsStringView()), std::move(conv.value())); } @@ -211,89 +211,89 @@ score::Result any_to_kvsvalue(const score::json::Any& any) noexcept } else { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } } -score::Result kvsvalue_to_any(const KvsValue& kv) noexcept +score::Result KvsValueToAny(const KvsValue& kv) noexcept { score::json::Object obj; - switch (kv.getType()) + switch (kv.GetType()) { - case KvsValue::Type::i32: + case KvsValue::Type::kI32: { obj.emplace("t", score::json::Any(std::string("i32"))); - obj.emplace("v", score::json::Any(static_cast(std::get(kv.getValue())))); + obj.emplace("v", score::json::Any(static_cast(std::get(kv.GetValue())))); break; } - case KvsValue::Type::u32: + case KvsValue::Type::kU32: { obj.emplace("t", score::json::Any(std::string("u32"))); - obj.emplace("v", score::json::Any(static_cast(std::get(kv.getValue())))); + obj.emplace("v", score::json::Any(static_cast(std::get(kv.GetValue())))); break; } - case KvsValue::Type::i64: + case KvsValue::Type::kI64: { obj.emplace("t", score::json::Any(std::string("i64"))); - obj.emplace("v", score::json::Any(static_cast(std::get(kv.getValue())))); + obj.emplace("v", score::json::Any(static_cast(std::get(kv.GetValue())))); break; } - case KvsValue::Type::u64: + case KvsValue::Type::kU64: { obj.emplace("t", score::json::Any(std::string("u64"))); - obj.emplace("v", score::json::Any(static_cast(std::get(kv.getValue())))); + obj.emplace("v", score::json::Any(static_cast(std::get(kv.GetValue())))); break; } - case KvsValue::Type::f64: + case KvsValue::Type::kF64: { obj.emplace("t", score::json::Any(std::string("f64"))); - obj.emplace("v", score::json::Any(std::get(kv.getValue()))); + obj.emplace("v", score::json::Any(std::get(kv.GetValue()))); break; } - case KvsValue::Type::Boolean: + case KvsValue::Type::kBoolean: { obj.emplace("t", score::json::Any(std::string("bool"))); - obj.emplace("v", score::json::Any(std::get(kv.getValue()))); + obj.emplace("v", score::json::Any(std::get(kv.GetValue()))); break; } - case KvsValue::Type::String: + case KvsValue::Type::kString: { obj.emplace("t", score::json::Any(std::string("str"))); - obj.emplace("v", score::json::Any(std::get(kv.getValue()))); + obj.emplace("v", score::json::Any(std::get(kv.GetValue()))); break; } - case KvsValue::Type::Null: + case KvsValue::Type::kNull: { obj.emplace("t", score::json::Any(std::string("null"))); obj.emplace("v", score::json::Any(score::json::Null{})); break; } - case KvsValue::Type::Array: + case KvsValue::Type::kArray: { obj.emplace("t", score::json::Any(std::string("arr"))); score::json::List list; - for (const auto& elem : std::get(kv.getValue())) + for (const auto& elem : std::get(kv.GetValue())) { - auto conv = kvsvalue_to_any(elem); + auto conv = KvsValueToAny(elem); if (!conv) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } list.push_back(std::move(conv.value())); } obj.emplace("v", score::json::Any(std::move(list))); break; } - case KvsValue::Type::Object: + case KvsValue::Type::kObject: { obj.emplace("t", score::json::Any(std::string("obj"))); score::json::Object inner_obj; - for (const auto& [key, value] : std::get(kv.getValue())) + for (const auto& [key, value] : std::get(kv.GetValue())) { - auto conv = kvsvalue_to_any(value); + auto conv = KvsValueToAny(value); if (!conv) { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } inner_obj.emplace(key, std::move(conv.value())); } @@ -302,7 +302,7 @@ score::Result kvsvalue_to_any(const KvsValue& kv) noexcept } default: { - return score::MakeUnexpected(ErrorCode::InvalidValueType); + return score::MakeUnexpected(ErrorCode::kInvalidValueType); } } diff --git a/score/kvs/internal/kvs_helper.h b/score/kvs/internal/kvs_helper.h index 82b9b3858..e76ff27b2 100644 --- a/score/kvs/internal/kvs_helper.h +++ b/score/kvs/internal/kvs_helper.h @@ -29,17 +29,17 @@ namespace score::kvs /// @brief Parses an Adler-32 checksum from its big-endian byte representation. /// @param in Stream to read the 4 checksum bytes from. /// @return The parsed checksum. -uint32_t parse_hash_adler32(std::istream& in) noexcept; +uint32_t ParseHashAdler32(std::istream& in) noexcept; /// @brief Calculates the Adler-32 checksum of the data. /// @param data Data to calculate the checksum of. /// @return The calculated checksum. -uint32_t calculate_hash_adler32(const std::string& data) noexcept; +uint32_t CalculateHashAdler32(const std::string& data) noexcept; /// @brief Splits an Adler-32 checksum into its big-endian bytes for writing. /// @param hash The checksum to split. /// @return The checksum bytes. -std::array get_hash_bytes_adler32(const uint32_t hash) noexcept; +std::array GetHashBytesAdler32(const uint32_t hash) noexcept; /// @brief Calculates the checksum of the data and returns it as bytes for writing. /// @@ -47,7 +47,7 @@ std::array get_hash_bytes_adler32(const uint32_t hash) noexcept; /// /// @param data Data to calculate the checksum of. /// @return The checksum bytes. -std::array get_hash_bytes(const std::string& data) noexcept; +std::array GetHashBytes(const std::string& data) noexcept; /// @brief Checks if the checksum read from a stream matches the data. /// @@ -56,17 +56,17 @@ std::array get_hash_bytes(const std::string& data) noexcept; /// @param data_calculate Data to calculate the checksum of. /// @param data_parse Stream to read the expected checksum from. /// @return `true` if the checksums match. -bool check_hash(const std::string& data_calculate, std::istream& data_parse) noexcept; +bool CheckHash(const std::string& data_calculate, std::istream& data_parse) noexcept; /// @brief Converts a JSON value in the KVS file format (`{"t": , "v": }`) to a KvsValue. /// @param any The JSON value to convert. -/// @return The converted value on success, or ErrorCode::InvalidValueType on failure. -score::Result any_to_kvsvalue(const score::json::Any& any) noexcept; +/// @return The converted value on success, or ErrorCode::kInvalidValueType on failure. +score::Result AnyToKvsValue(const score::json::Any& any) noexcept; /// @brief Converts a KvsValue to a JSON value in the KVS file format (`{"t": , "v": }`). /// @param kv The value to convert. -/// @return The converted JSON value on success, or ErrorCode::InvalidValueType on failure. -score::Result kvsvalue_to_any(const KvsValue& kv) noexcept; +/// @return The converted JSON value on success, or ErrorCode::kInvalidValueType on failure. +score::Result KvsValueToAny(const KvsValue& kv) noexcept; } // namespace score::kvs diff --git a/score/kvs/kvs.cpp b/score/kvs/kvs.cpp index ed1f00096..1f98a7808 100644 --- a/score/kvs/kvs.cpp +++ b/score/kvs/kvs.cpp @@ -37,17 +37,17 @@ namespace score::kvs namespace { /// @brief Size of a snapshot hash file in bytes (Adler-32 checksum). -constexpr size_t HASH_FILE_SIZE = 4U; +constexpr size_t kHashFileSize = 4U; /// @brief Checks that a key is valid. /// /// A valid key: -/// - is 1 to KVS_MAX_KEY_LENGTH_BYTES bytes long, +/// - is 1 to kMaxKeyLengthBytes bytes long, /// - consists solely of printable ASCII characters (0x20 - 0x7E). -bool is_key_valid(const std::string_view key) noexcept +bool IsKeyValid(const std::string_view key) noexcept { // comp_req__kvs__key_length: disallow empty keys and keys too long. - if (key.empty() || key.length() > KVS_MAX_KEY_LENGTH_BYTES) + if (key.empty() || key.length() > kMaxKeyLengthBytes) { return false; } @@ -60,11 +60,11 @@ bool is_key_valid(const std::string_view key) noexcept } /// @brief Permissions of KVS JSON and hash files: 0640. -constexpr score::os::Stat::Mode KVS_FILE_MODE{score::os::Stat::Mode::kReadUser | score::os::Stat::Mode::kWriteUser | - score::os::Stat::Mode::kReadGroup}; +constexpr score::os::Stat::Mode kKvsFileMode{score::os::Stat::Mode::kReadUser | score::os::Stat::Mode::kWriteUser | + score::os::Stat::Mode::kReadGroup}; /// @brief Returns the path of the temporary file a KVS file is written to before it replaces the KVS file. -score::filesystem::Path temp_file_path(const score::filesystem::Path& path) noexcept +score::filesystem::Path TempFilePath(const score::filesystem::Path& path) noexcept { return score::filesystem::Path{path.Native() + ".tmp"}; } @@ -72,7 +72,7 @@ score::filesystem::Path temp_file_path(const score::filesystem::Path& path) noex /// @brief Removes a file. /// /// A missing file is not an error. -bool remove_if_exists(const score::filesystem::Path& path) noexcept +bool RemoveIfExists(const score::filesystem::Path& path) noexcept { const auto result = score::os::Unistd::instance().unlink(path.CStr()); return result.has_value() || (result.error() == score::os::Error::Code::kNoSuchFileOrDirectory); @@ -80,7 +80,7 @@ bool remove_if_exists(const score::filesystem::Path& path) noexcept } // namespace Kvs::Kvs() noexcept - : max_snapshots_(KVS_DEFAULT_MAX_SNAPSHOTS), + : max_snapshots_(kDefaultMaxSnapshots), filesystem_( std::make_unique(score::filesystem::FilesystemFactory{}.CreateInstance())), parser_(std::make_unique()), @@ -129,19 +129,19 @@ Kvs& Kvs::operator=(Kvs&& other) noexcept return *this; } -score::Result Kvs::parse_json_data(const std::string& data) const noexcept +score::Result Kvs::ParseJsonData(const std::string& data) const noexcept { auto any_res = parser_->FromBuffer(data); if (!any_res) { - return score::MakeUnexpected(ErrorCode::JsonParserError); + return score::MakeUnexpected(ErrorCode::kJsonParserError); } score::json::Any root = std::move(any_res).value(); const auto obj = root.As(); if (!obj.has_value()) { - return score::MakeUnexpected(ErrorCode::JsonParserError); + return score::MakeUnexpected(ErrorCode::kJsonParserError); } KeyValueMap result_value; @@ -151,13 +151,13 @@ score::Result Kvs::parse_json_data(const std::string& data) co std::string key(sv.data(), sv.size()); // Validate key. - if (!is_key_valid(sv)) + if (!IsKeyValid(sv)) { logger_->LogError() << "Provided key is not valid" << key; - return score::MakeUnexpected(ErrorCode::InvalidKey); + return score::MakeUnexpected(ErrorCode::kInvalidKey); } - auto conv = any_to_kvsvalue(element.second); + auto conv = AnyToKvsValue(element.second); if (!conv) { return score::MakeUnexpected(static_cast(*conv.error())); @@ -168,8 +168,8 @@ score::Result Kvs::parse_json_data(const std::string& data) co return result_value; } -score::Result Kvs::open_json(const score::filesystem::Path& prefix, - const OpenJsonNeedFile need_file) const noexcept +score::Result Kvs::OpenJson(const score::filesystem::Path& prefix, + const OpenJsonNeedFile need_file) const noexcept { const score::filesystem::Path json_file = prefix.Native() + ".json"; const score::filesystem::Path hash_file = prefix.Native() + ".hash"; @@ -178,10 +178,10 @@ score::Result Kvs::open_json(const score::filesystem::Path& pr std::ifstream in(json_file.CStr()); if (!in) { - if (need_file == OpenJsonNeedFile::Required) + if (need_file == OpenJsonNeedFile::kRequired) { logger_->LogError() << "error: file" << json_file << "could not be read"; - return score::MakeUnexpected(ErrorCode::KvsFileReadError); + return score::MakeUnexpected(ErrorCode::kKvsFileReadError); } else { @@ -199,17 +199,17 @@ score::Result Kvs::open_json(const score::filesystem::Path& pr if (!hin) { logger_->LogError() << "error: hash file" << hash_file << "could not be read"; - return score::MakeUnexpected(ErrorCode::KvsHashFileReadError); + return score::MakeUnexpected(ErrorCode::kKvsHashFileReadError); } - if (!check_hash(data, hin)) + if (!CheckHash(data, hin)) { logger_->LogError() << "error: KVS data corrupted:" << json_file << hash_file; - return score::MakeUnexpected(ErrorCode::ValidationFailed); + return score::MakeUnexpected(ErrorCode::kValidationFailed); } logger_->LogInfo() << "JSON data has valid hash"; // Parse JSON data. - auto parse_res = parse_json_data(data); + auto parse_res = ParseJsonData(data); if (!parse_res) { logger_->LogError() << "error: parsing JSON data failed"; @@ -219,15 +219,15 @@ score::Result Kvs::open_json(const score::filesystem::Path& pr return std::move(parse_res.value()); } -score::Result Kvs::open(const InstanceId& instance_id, +score::Result Kvs::Open(const InstanceId& instance_id, const SnapshotId& snapshot_id, - const OpenNeedDefaults& need_defaults, - const OpenNeedKvs& need_kvs, - const std::string& dir, + const KvsDefaults& defaults, + const KvsLoad& kvs_load, + const std::string& working_dir, const std::optional& max_storage_bytes, const std::size_t snapshot_max_count) noexcept { - const score::filesystem::Path base_path(dir); + const score::filesystem::Path base_path(working_dir); const score::filesystem::Path filename_prefix = base_path / ("kvs_" + std::to_string(instance_id.id)); const score::filesystem::Path filename_default = filename_prefix.Native() + "_default"; const score::filesystem::Path filename_kvs = filename_prefix.Native() + "_" + std::to_string(snapshot_id.id); @@ -236,11 +236,11 @@ score::Result Kvs::open(const InstanceId& instance_id, kvs.max_storage_bytes_ = max_storage_bytes; score::Result default_res{}; - if (need_defaults != OpenNeedDefaults::Ignored) + if (defaults != KvsDefaults::kIgnored) { - default_res = kvs.open_json( + default_res = kvs.OpenJson( filename_default, - need_defaults == OpenNeedDefaults::Required ? OpenJsonNeedFile::Required : OpenJsonNeedFile::Optional); + defaults == KvsDefaults::kRequired ? OpenJsonNeedFile::kRequired : OpenJsonNeedFile::kOptional); } if (!default_res) @@ -251,10 +251,10 @@ score::Result Kvs::open(const InstanceId& instance_id, score::Result kvs_res{}; - if (need_kvs != OpenNeedKvs::Ignored) + if (kvs_load != KvsLoad::kIgnored) { - kvs_res = kvs.open_json( - filename_kvs, need_kvs == OpenNeedKvs::Required ? OpenJsonNeedFile::Required : OpenJsonNeedFile::Optional); + kvs_res = kvs.OpenJson( + filename_kvs, kvs_load == KvsLoad::kRequired ? OpenJsonNeedFile::kRequired : OpenJsonNeedFile::kOptional); } if (!kvs_res) @@ -266,14 +266,14 @@ score::Result Kvs::open(const InstanceId& instance_id, kvs.default_values_ = std::move(default_res.value()); kvs.filename_prefix_ = filename_prefix; - // comp_req__kvs__snapshot_max_num_cfg: the maximum is limited to the range 0..KVS_MAX_SNAPSHOTS_UPPER_BOUND. + // comp_req__kvs__snapshot_max_num_cfg: the maximum is limited to the range 0..kMaxSnapshotsUpperBound. // A larger request is clamped and reported, so that the caller can see the value it actually got. kvs.max_snapshots_ = snapshot_max_count; - if (snapshot_max_count > KVS_MAX_SNAPSHOTS_UPPER_BOUND) + if (snapshot_max_count > kMaxSnapshotsUpperBound) { kvs.logger_->LogWarn() << "snapshot_max_count" << snapshot_max_count << "exceeds upper bound" - << KVS_MAX_SNAPSHOTS_UPPER_BOUND << "- clamped"; - kvs.max_snapshots_ = KVS_MAX_SNAPSHOTS_UPPER_BOUND; + << kMaxSnapshotsUpperBound << "- clamped"; + kvs.max_snapshots_ = kMaxSnapshotsUpperBound; } kvs.logger_->LogInfo() << "[instance=" << instance_id.id << "]" @@ -282,24 +282,24 @@ score::Result Kvs::open(const InstanceId& instance_id, return kvs; } -score::Result Kvs::reset() noexcept +score::Result Kvs::Reset() noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } kvs_.clear(); return {}; } -score::Result> Kvs::get_all_keys() const noexcept +score::Result> Kvs::GetAllKeys() const noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } std::vector keys; @@ -311,12 +311,12 @@ score::Result> Kvs::get_all_keys() const noexcept return keys; } -score::Result Kvs::key_exists(const std::string_view key) const noexcept +score::Result Kvs::KeyExists(const std::string_view key) const noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } // unordered_map find() needs string and doesn't work with string_view. @@ -324,43 +324,43 @@ score::Result Kvs::key_exists(const std::string_view key) const noexcept return kvs_.find(std::string(key)) != kvs_.end(); } -score::Result Kvs::get_value(const std::string_view key) const noexcept +score::Result Kvs::GetValue(const std::string_view key) const noexcept { std::unique_lock lock_kvs(kvs_mutex_, std::try_to_lock); if (!lock_kvs.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } const auto search_kvs = kvs_.find(std::string(key)); if (search_kvs == kvs_.end()) { - return score::MakeUnexpected(ErrorCode::KeyNotFound); + return score::MakeUnexpected(ErrorCode::kKeyNotFound); } return search_kvs->second; } -score::Result Kvs::get_default_value(const std::string_view key) const noexcept +score::Result Kvs::GetDefaultValue(const std::string_view key) const noexcept { const auto search = default_values_.find(std::string(key)); if (search == default_values_.end()) { - return score::MakeUnexpected(ErrorCode::KeyNotFound); + return score::MakeUnexpected(ErrorCode::kKeyNotFound); } return search->second; } -score::Result Kvs::reset_key(const std::string_view key) noexcept +score::Result Kvs::ResetKey(const std::string_view key) noexcept { std::unique_lock lock_kvs(kvs_mutex_, std::try_to_lock); if (!lock_kvs.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } if (default_values_.find(std::string(key)) == default_values_.end()) { - return score::MakeUnexpected(ErrorCode::KeyDefaultNotFound); + return score::MakeUnexpected(ErrorCode::kKeyDefaultNotFound); } // Return value ignored: a key that was never written needs no reset. @@ -368,12 +368,12 @@ score::Result Kvs::reset_key(const std::string_view key) noexcept return {}; } -score::Result Kvs::is_value_default(const std::string_view key) const noexcept +score::Result Kvs::IsValueDefault(const std::string_view key) const noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } const std::string key_str{key}; @@ -387,69 +387,69 @@ score::Result Kvs::is_value_default(const std::string_view key) const noex } else { - return score::MakeUnexpected(ErrorCode::KeyNotFound); + return score::MakeUnexpected(ErrorCode::kKeyNotFound); } } -score::Result Kvs::set_value(const std::string_view key, const KvsValue& value) noexcept +score::Result Kvs::SetValue(const std::string_view key, const KvsValue& value) noexcept { // Validate key. - if (!is_key_valid(key)) + if (!IsKeyValid(key)) { logger_->LogError() << "Provided key is not valid" << key; - return score::MakeUnexpected(ErrorCode::InvalidKey); + return score::MakeUnexpected(ErrorCode::kInvalidKey); } std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } kvs_.insert_or_assign(std::string(key), value); return {}; } -score::Result Kvs::remove_key(const std::string_view key) noexcept +score::Result Kvs::RemoveKey(const std::string_view key) noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } if (kvs_.erase(std::string(key)) == 0U) { - return score::MakeUnexpected(ErrorCode::KeyNotFound); + return score::MakeUnexpected(ErrorCode::kKeyNotFound); } return {}; } -score::Result Kvs::remove_all_keys() noexcept +score::Result Kvs::RemoveAllKeys() noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } kvs_.clear(); return {}; } -score::Result Kvs::discard_pending_changes() noexcept +score::Result Kvs::DiscardPendingChanges() noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } - // Snapshot 0 is the current persisted state: written by flush(), read by open(). + // Snapshot 0 is the current persisted state: written by Flush(), read by Open(). const score::filesystem::Path kvs_path = filename_prefix_.Native() + "_0"; // Optional: a KVS opened without an existing file and never flushed discards to empty. - auto data_res = open_json(kvs_path, OpenJsonNeedFile::Optional); + auto data_res = OpenJson(kvs_path, OpenJsonNeedFile::kOptional); if (!data_res) { return score::MakeUnexpected(static_cast(*data_res.error())); @@ -459,7 +459,7 @@ score::Result Kvs::discard_pending_changes() noexcept return {}; } -score::Result Kvs::get_file_size(const score::filesystem::Path& file_path) const noexcept +score::Result Kvs::GetFileSize(const score::filesystem::Path& file_path) const noexcept { std::error_code ec; const auto size = std::filesystem::file_size(file_path.CStr(), ec); @@ -476,14 +476,14 @@ score::Result Kvs::get_file_size(const score::filesystem::Path& file_pat else { logger_->LogError() << "Error: Could not get size of file" << file_path << ":" << ec.message(); - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } } return size; } -score::Result Kvs::get_current_storage_size() const noexcept +score::Result Kvs::GetCurrentStorageSize() const noexcept { size_t total_size = 0; const std::array file_extensions = {".json", ".hash"}; @@ -493,7 +493,7 @@ score::Result Kvs::get_current_storage_size() const noexcept for (const char* extension : file_extensions) { const score::filesystem::Path file_path = filename_prefix_.Native() + default_suffix + extension; - auto size_result = get_file_size(file_path); + auto size_result = GetFileSize(file_path); if (!size_result) { return size_result; @@ -509,7 +509,7 @@ score::Result Kvs::get_current_storage_size() const noexcept for (const char* extension : file_extensions) { const score::filesystem::Path file_path = filename_prefix_.Native() + snapshot_suffix + extension; - auto size_result = get_file_size(file_path); + auto size_result = GetFileSize(file_path); if (!size_result) { return size_result; @@ -520,28 +520,28 @@ score::Result Kvs::get_current_storage_size() const noexcept return total_size; } -score::Result Kvs::write_temp_file(const score::filesystem::Path& path, - const void* data, - const std::size_t size) const noexcept +score::Result Kvs::WriteTempFile(const score::filesystem::Path& path, + const void* data, + const std::size_t size) const noexcept { const score::os::Unistd& unistd = score::os::Unistd::instance(); - const score::filesystem::Path tmp_path = temp_file_path(path); + const score::filesystem::Path tmp_path = TempFilePath(path); // Remove a temporary file left behind by an interrupted write. - if (!remove_if_exists(tmp_path)) + if (!RemoveIfExists(tmp_path)) { logger_->LogError() << "Failed to remove stale temporary file" << tmp_path; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } // Create a new file: the mode is applied on creation and a file planted at the path is never opened. using Open = score::os::Fcntl::Open; const auto open_result = score::os::Fcntl::instance().open( - tmp_path.CStr(), Open::kWriteOnly | Open::kCreate | Open::kExclusive | Open::kCloseOnExec, KVS_FILE_MODE); + tmp_path.CStr(), Open::kWriteOnly | Open::kCreate | Open::kExclusive | Open::kCloseOnExec, kKvsFileMode); if (!open_result.has_value()) { logger_->LogError() << "Failed to open file" << tmp_path; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } const std::int32_t fd = open_result.value(); @@ -549,11 +549,11 @@ score::Result Kvs::write_temp_file(const score::filesystem::Path& path, const auto discard = [&unistd, &tmp_path, fd]() { score::cpp::ignore = unistd.close(fd); score::cpp::ignore = unistd.unlink(tmp_path.CStr()); - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); }; // Set the mode on the open file, the mode given on creation is restricted by umask. - if (!score::os::Stat::instance().fchmod(fd, KVS_FILE_MODE).has_value()) + if (!score::os::Stat::instance().fchmod(fd, kKvsFileMode).has_value()) { logger_->LogError() << "Failed to set file permissions" << tmp_path; return discard(); @@ -587,26 +587,26 @@ score::Result Kvs::write_temp_file(const score::filesystem::Path& path, { logger_->LogError() << "Failed to close file" << tmp_path; score::cpp::ignore = unistd.unlink(tmp_path.CStr()); - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } return {}; } -score::Result Kvs::commit_temp_file(const score::filesystem::Path& path) const noexcept +score::Result Kvs::CommitTempFile(const score::filesystem::Path& path) const noexcept { - const score::filesystem::Path tmp_path = temp_file_path(path); + const score::filesystem::Path tmp_path = TempFilePath(path); if (!score::os::Stdio::instance().rename(tmp_path.CStr(), path.CStr()).has_value()) { logger_->LogError() << "Failed to replace file" << path; - score::cpp::ignore = remove_if_exists(tmp_path); - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + score::cpp::ignore = RemoveIfExists(tmp_path); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } return {}; } -score::Result Kvs::write_json_data(const std::string& buf) const noexcept +score::Result Kvs::WriteJsonData(const std::string& buf) const noexcept { const score::filesystem::Path json_path{filename_prefix_.Native() + "_0.json"}; const score::filesystem::Path hash_path{filename_prefix_.Native() + "_0.hash"}; @@ -614,40 +614,40 @@ score::Result Kvs::write_json_data(const std::string& buf) const noexcept if (dir.Empty()) { logger_->LogError() << "Provided directory path is empty" << json_path; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } const auto create_path_res = filesystem_->standard->CreateDirectories(dir); if (!create_path_res.has_value()) { logger_->LogError() << "Failed to create directory for KVS file" << json_path; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } // Write JSON and hash files to temporary files, the live files stay untouched. - auto json_res = write_temp_file(json_path, buf.data(), buf.size()); + auto json_res = WriteTempFile(json_path, buf.data(), buf.size()); if (!json_res.has_value()) { return json_res; } - const std::array hash_bytes = get_hash_bytes(buf); - auto hash_res = write_temp_file(hash_path, hash_bytes.data(), hash_bytes.size()); + const std::array hash_bytes = GetHashBytes(buf); + auto hash_res = WriteTempFile(hash_path, hash_bytes.data(), hash_bytes.size()); if (!hash_res.has_value()) { - score::cpp::ignore = remove_if_exists(temp_file_path(json_path)); + score::cpp::ignore = RemoveIfExists(TempFilePath(json_path)); return hash_res; } // Replace live files with temporary files. - auto json_commit_res = commit_temp_file(json_path); + auto json_commit_res = CommitTempFile(json_path); if (!json_commit_res.has_value()) { - score::cpp::ignore = remove_if_exists(temp_file_path(hash_path)); + score::cpp::ignore = RemoveIfExists(TempFilePath(hash_path)); return json_commit_res; } - auto hash_commit_res = commit_temp_file(hash_path); + auto hash_commit_res = CommitTempFile(hash_path); if (!hash_commit_res.has_value()) { return hash_commit_res; @@ -657,13 +657,13 @@ score::Result Kvs::write_json_data(const std::string& buf) const noexcept if (!filesystem_->utils->SyncDirectory(dir).has_value()) { logger_->LogError() << "Failed to sync directory" << dir; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } return {}; } -score::Result Kvs::serialize_and_check() const noexcept +score::Result Kvs::SerializeAndCheck() const noexcept { score::json::Object root_obj; @@ -672,11 +672,11 @@ score::Result Kvs::serialize_and_check() const noexcept std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } for (const auto& [key, value] : kvs_) { - auto conv = kvsvalue_to_any(value); + auto conv = KvsValueToAny(value); if (!conv) { return score::MakeUnexpected(conv.error()); @@ -688,73 +688,73 @@ score::Result Kvs::serialize_and_check() const noexcept auto buf_res = writer_->ToBuffer(root_obj); if (!buf_res) { - return score::MakeUnexpected(ErrorCode::JsonGeneratorError); + return score::MakeUnexpected(ErrorCode::kJsonGeneratorError); } const std::string& buf = buf_res.value(); // Without a configured limit there is nothing to check, so the persisted files are not measured at all. - // flush() then behaves exactly as it does without this feature: no extra file system calls, and no new way to fail. + // Flush() then behaves exactly as it does without this feature: no extra file system calls, and no new way to fail. if (max_storage_bytes_.has_value()) { // 2. Size of all other persisted files. - const auto current_size_res = get_current_storage_size(); + const auto current_size_res = GetCurrentStorageSize(); if (!current_size_res) { return score::MakeUnexpected(current_size_res.error()); } // 3. Projected total after this flush. - const size_t total_size = current_size_res.value() + buf.size() + HASH_FILE_SIZE; + const size_t total_size = current_size_res.value() + buf.size() + kHashFileSize; // 4. Check against the limit. if (total_size > max_storage_bytes_.value()) { logger_->LogError() << "error: KVS storage limit would be exceeded. total_size:" << total_size << "max_storage_bytes:" << max_storage_bytes_.value(); - return score::MakeUnexpected(ErrorCode::OutOfStorageSpace); + return score::MakeUnexpected(ErrorCode::kOutOfStorageSpace); } } return buf; } -score::Result Kvs::flush() noexcept +score::Result Kvs::Flush() noexcept { - auto result = serialize_and_check(); + auto result = SerializeAndCheck(); if (!result) { return score::MakeUnexpected(result.error()); } - auto rotate_result = snapshot_rotate(); + auto rotate_result = SnapshotRotate(); if (!rotate_result) { return rotate_result; } - return write_json_data(result.value()); + return WriteJsonData(result.value()); } -score::Result Kvs::calculate_potential_size() const noexcept +score::Result Kvs::CalculatePotentialSize() const noexcept { - auto result = serialize_and_check(); + auto result = SerializeAndCheck(); if (!result) { return score::MakeUnexpected(result.error()); } - // Re-calculate the size to return it, as serialize_and_check() only returns the buffer. + // Re-calculate the size to return it, as SerializeAndCheck() only returns the buffer. const std::string& buf = result.value(); - const auto current_size_res = get_current_storage_size(); + const auto current_size_res = GetCurrentStorageSize(); if (!current_size_res) { return score::MakeUnexpected(current_size_res.error()); } - return current_size_res.value() + buf.size() + HASH_FILE_SIZE; + return current_size_res.value() + buf.size() + kHashFileSize; } -score::Result Kvs::snapshot_count() const noexcept +score::Result Kvs::SnapshotCount() const noexcept { size_t count = 0; for (size_t idx = 0; idx < max_snapshots_; ++idx) @@ -763,7 +763,7 @@ score::Result Kvs::snapshot_count() const noexcept const auto fname_exists_res = filesystem_->standard->Exists(fname); if (!fname_exists_res) { - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } if (false == fname_exists_res.value()) { @@ -775,17 +775,17 @@ score::Result Kvs::snapshot_count() const noexcept return count; } -size_t Kvs::snapshot_max_count() const noexcept +size_t Kvs::SnapshotMaxCount() const noexcept { return max_snapshots_; } -score::Result Kvs::snapshot_rotate() const noexcept +score::Result Kvs::SnapshotRotate() const noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } for (size_t idx = max_snapshots_; idx > 0; --idx) @@ -801,7 +801,7 @@ score::Result Kvs::snapshot_rotate() const noexcept if ((0 != hash_rename) && (errno != ENOENT)) { logger_->LogError() << "error: could not rename hash file" << snap_old << "- Rename Errorcode" << errno; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } // Rename snapshot. @@ -809,22 +809,22 @@ score::Result Kvs::snapshot_rotate() const noexcept if ((0 != snap_rename) && (errno != ENOENT)) { logger_->LogError() << "error: could not rename snapshot file" << snap_old << "- Rename Errorcode" << errno; - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } } return {}; } -score::Result Kvs::snapshot_restore(const SnapshotId& snapshot_id) noexcept +score::Result Kvs::SnapshotRestore(const SnapshotId& snapshot_id) noexcept { std::unique_lock lock(kvs_mutex_, std::try_to_lock); if (!lock.owns_lock()) { - return score::MakeUnexpected(ErrorCode::MutexLockFailed); + return score::MakeUnexpected(ErrorCode::kMutexLockFailed); } - const auto snapshot_count_res = snapshot_count(); + const auto snapshot_count_res = SnapshotCount(); if (!snapshot_count_res) { return score::MakeUnexpected(static_cast(*snapshot_count_res.error())); @@ -833,11 +833,11 @@ score::Result Kvs::snapshot_restore(const SnapshotId& snapshot_id) noexcep // Fail if the snapshot ID is the current KVS or does not exist. if ((0 == snapshot_id.id) || (snapshot_count_res.value() < snapshot_id.id)) { - return score::MakeUnexpected(ErrorCode::InvalidSnapshotId); + return score::MakeUnexpected(ErrorCode::kInvalidSnapshotId); } const score::filesystem::Path restore_path = filename_prefix_.Native() + "_" + std::to_string(snapshot_id.id); - auto data_res = open_json(restore_path, OpenJsonNeedFile::Required); + auto data_res = OpenJson(restore_path, OpenJsonNeedFile::kRequired); if (!data_res) { return score::MakeUnexpected(static_cast(*data_res.error())); @@ -847,7 +847,7 @@ score::Result Kvs::snapshot_restore(const SnapshotId& snapshot_id) noexcep return {}; } -score::Result Kvs::get_kvs_filename(const SnapshotId& snapshot_id) const noexcept +score::Result Kvs::KvsFilePath(const SnapshotId& snapshot_id) const noexcept { score::filesystem::Path filename = filename_prefix_.Native() + "_" + std::to_string(snapshot_id.id) + ".json"; @@ -858,12 +858,12 @@ score::Result Kvs::get_kvs_filename(const SnapshotId& s } if (false == fname_exists_res.value()) { - return score::MakeUnexpected(ErrorCode::FileNotFound); + return score::MakeUnexpected(ErrorCode::kFileNotFound); } return filename; } -score::Result Kvs::get_hash_filename(const SnapshotId& snapshot_id) const noexcept +score::Result Kvs::HashFilePath(const SnapshotId& snapshot_id) const noexcept { score::filesystem::Path filename = filename_prefix_.Native() + "_" + std::to_string(snapshot_id.id) + ".hash"; @@ -874,12 +874,12 @@ score::Result Kvs::get_hash_filename(const SnapshotId& } if (false == fname_exists_res.value()) { - return score::MakeUnexpected(ErrorCode::FileNotFound); + return score::MakeUnexpected(ErrorCode::kFileNotFound); } return filename; } -score::Result Kvs::get_storage_file_size() const noexcept +score::Result Kvs::GetStorageFileSize() const noexcept { const std::array paths{score::filesystem::Path{filename_prefix_.Native() + "_0.json"}, score::filesystem::Path{filename_prefix_.Native() + "_0.hash"}}; @@ -896,7 +896,7 @@ score::Result Kvs::get_storage_file_size() const noexcept else if (ec != std::errc::no_such_file_or_directory) { logger_->LogError() << "error: could not determine size of " << path << ": " << ec.message(); - return score::MakeUnexpected(ErrorCode::PhysicalStorageFailure); + return score::MakeUnexpected(ErrorCode::kPhysicalStorageFailure); } } diff --git a/score/kvs/kvs.h b/score/kvs/kvs.h index 376f71fd2..e61dd51e9 100644 --- a/score/kvs/kvs.h +++ b/score/kvs/kvs.h @@ -35,20 +35,32 @@ namespace score::kvs /// @brief Maximum allowed key length in bytes. /// @note comp_req__kvs__key_length -constexpr std::size_t KVS_MAX_KEY_LENGTH_BYTES = 32U; +constexpr std::size_t kMaxKeyLengthBytes = 32U; + +/// @deprecated Use `kMaxKeyLengthBytes` instead. +[[deprecated("Use kMaxKeyLengthBytes instead. This name is removed in a future release.")]] +constexpr std::size_t KVS_MAX_KEY_LENGTH_BYTES = kMaxKeyLengthBytes; /// @brief Upper bound of the configurable maximum number of snapshots. /// -/// The configurable maximum number of snapshots is limited to the range 0..KVS_MAX_SNAPSHOTS_UPPER_BOUND. +/// The configurable maximum number of snapshots is limited to the range 0..kMaxSnapshotsUpperBound. /// A value of 0 disables snapshot operations. /// @note comp_req__kvs__snapshot_max_num_cfg -constexpr std::size_t KVS_MAX_SNAPSHOTS_UPPER_BOUND = 3U; +constexpr std::size_t kMaxSnapshotsUpperBound = 3U; + +/// @deprecated Use `kMaxSnapshotsUpperBound` instead. +[[deprecated("Use kMaxSnapshotsUpperBound instead. This name is removed in a future release.")]] +constexpr std::size_t KVS_MAX_SNAPSHOTS_UPPER_BOUND = kMaxSnapshotsUpperBound; /// @brief Default maximum number of snapshots. /// -/// It can be overridden per instance at init-time via KvsBuilder::snapshot_max_count(). +/// It can be overridden per instance at init-time via KvsBuilder::SnapshotMaxCount(). /// @note comp_req__kvs__snapshot_max_num_cfg -constexpr std::size_t KVS_DEFAULT_MAX_SNAPSHOTS = 3U; +constexpr std::size_t kDefaultMaxSnapshots = 3U; + +/// @deprecated Use `kDefaultMaxSnapshots` instead. +[[deprecated("Use kDefaultMaxSnapshots instead. This name is removed in a future release.")]] +constexpr std::size_t KVS_DEFAULT_MAX_SNAPSHOTS = kDefaultMaxSnapshots; /// @brief Identifier of a KVS instance. struct InstanceId @@ -83,34 +95,58 @@ struct SnapshotId }; /// @brief Whether default values must be available when opening a KVS. -enum class OpenNeedDefaults : std::uint8_t +enum class KvsDefaults : std::uint8_t { /// Defaults must be available. - Required = 0, + kRequired = 0, /// Use empty defaults if none are available. - Optional = 1, + kOptional = 1, /// Defaults are not loaded. - Ignored = 2, + kIgnored = 2, + + // Deprecated enumerators. + // Each one is an alias of its k-prefixed replacement and is removed in a future release. + Required [[deprecated("Use kRequired instead. This name is removed in a future release.")]] = kRequired, + Optional [[deprecated("Use kOptional instead. This name is removed in a future release.")]] = kOptional, + Ignored [[deprecated("Use kIgnored instead. This name is removed in a future release.")]] = kIgnored, }; +/// @deprecated Use `KvsDefaults` instead. +using OpenNeedDefaults [[deprecated("Use KvsDefaults instead. This name is removed in a future release.")]] = + KvsDefaults; + /// @brief Whether KVS data must already exist when opening a KVS. -enum class OpenNeedKvs : std::uint8_t +enum class KvsLoad : std::uint8_t { /// KVS data must already exist. - Required = 0, + kRequired = 0, /// Use an empty KVS if no KVS data is available. - Optional = 1, + kOptional = 1, /// KVS data is not loaded. - Ignored = 2, + kIgnored = 2, + + // Deprecated enumerators. + // Each one is an alias of its k-prefixed replacement and is removed in a future release. + Required [[deprecated("Use kRequired instead. This name is removed in a future release.")]] = kRequired, + Optional [[deprecated("Use kOptional instead. This name is removed in a future release.")]] = kOptional, + Ignored [[deprecated("Use kIgnored instead. This name is removed in a future release.")]] = kIgnored, }; +/// @deprecated Use `KvsLoad` instead. +using OpenNeedKvs [[deprecated("Use KvsLoad instead. This name is removed in a future release.")]] = KvsLoad; + /// @brief Whether a JSON file must exist when it is opened. enum class OpenJsonNeedFile : std::uint8_t { /// The file must already exist. - Required = 0, + kRequired = 0, /// If the file doesn't exist, start with empty data. - Optional = 1, + kOptional = 1, + + // Deprecated enumerators. + // Each one is an alias of its k-prefixed replacement and is removed in a future release. + Required [[deprecated("Use kRequired instead. This name is removed in a future release.")]] = kRequired, + Optional [[deprecated("Use kOptional instead. This name is removed in a future release.")]] = kOptional, }; /// @brief A thread-safe key-value store (KVS). @@ -140,41 +176,41 @@ class Kvs final /// This function initializes and opens the key-value store (KVS) for a given instance ID. /// It lets the caller specify whether default values and an existing KVS are required or optional. /// - /// @note Instead of using Kvs::open() directly, it is recommended to use the KvsBuilder class. + /// @note Instead of using Kvs::Open() directly, it is recommended to use the KvsBuilder class. /// /// @param instance_id The instance ID of the KVS. /// This uniquely identifies the KVS instance. /// @param snapshot_id The snapshot ID of the KVS. /// This uniquely identifies the KVS snapshot. - /// @param need_defaults Whether default values are required, optional or ignored. - /// @param need_kvs Whether the KVS data is required, optional or ignored. - /// @param dir The directory path where the KVS files are located. + /// @param defaults Whether default values are required, optional or ignored. + /// @param kvs_load Whether the KVS data is required, optional or ignored. + /// @param working_dir The directory path where the KVS files are located. /// Use "" or "." for the current directory. /// @param max_storage_bytes Optional maximum total storage size in bytes. /// Pass std::nullopt to enforce no storage limit. /// @param snapshot_max_count The maximum number of snapshots this instance maintains. - /// Values above KVS_MAX_SNAPSHOTS_UPPER_BOUND are clamped to it (a warning is logged). + /// Values above kMaxSnapshotsUpperBound are clamped to it (a warning is logged). /// A value of 0 disables snapshot operations. - /// The current KVS data is still persisted by flush(). + /// The current KVS data is still persisted by Flush(). /// @return The opened Kvs object on success, or an ErrorCode on failure. - static score::Result open(const InstanceId& instance_id, + static score::Result Open(const InstanceId& instance_id, const SnapshotId& snapshot_id, - const OpenNeedDefaults& need_defaults, - const OpenNeedKvs& need_kvs, - const std::string& dir, + const KvsDefaults& defaults, + const KvsLoad& kvs_load, + const std::string& working_dir, const std::optional& max_storage_bytes, const std::size_t snapshot_max_count) noexcept; /// @brief Resets the key-value store to its initial state. /// @return Nothing on success, or an ErrorCode on failure. - score::Result reset() noexcept; + score::Result Reset() noexcept; /// @brief Retrieves all keys stored in the key-value store. /// /// It only retrieves the written keys, no default keys are returned. /// /// @return All written keys on success, or an ErrorCode on failure. - score::Result> get_all_keys() const noexcept; + score::Result> GetAllKeys() const noexcept; /// @brief Checks if a key exists in the key-value store. /// @@ -182,12 +218,12 @@ class Kvs final /// /// @param key The key to check for existence. /// @return `true` if the key exists and `false` if it does not on success, or an ErrorCode on failure. - score::Result key_exists(const std::string_view key) const noexcept; + score::Result KeyExists(const std::string_view key) const noexcept; /// @brief Retrieves the value associated with the specified key from the key-value store. /// @param key The key for which the value is to be retrieved. /// @return The retrieved value on success, or an ErrorCode on failure. - score::Result get_value(const std::string_view key) const noexcept; + score::Result GetValue(const std::string_view key) const noexcept; /// @brief Retrieves the default value associated with the specified key. /// @@ -196,7 +232,7 @@ class Kvs final /// /// @param key The key for which the default value is to be retrieved. /// @return The default value on success, or an ErrorCode on failure. - score::Result get_default_value(const std::string_view key) const noexcept; + score::Result GetDefaultValue(const std::string_view key) const noexcept; /// @brief Resets a specified key to its default value. /// @@ -206,68 +242,68 @@ class Kvs final /// /// @param key The key to be reset to its default value. /// @return Nothing on success, or an ErrorCode on failure. - score::Result reset_key(const std::string_view key) noexcept; + score::Result ResetKey(const std::string_view key) noexcept; /// @brief Checks if the specified key wasn't set yet and uses its default value. /// @param key The key to check. /// @return `true` if the key uses its default value on success, or an ErrorCode on failure. - score::Result is_value_default(const std::string_view key) const noexcept; + score::Result IsValueDefault(const std::string_view key) const noexcept; /// @brief Stores a key-value pair in the key-value store. /// - /// The key length is limited to KVS_MAX_KEY_LENGTH_BYTES (32) bytes. + /// The key length is limited to kMaxKeyLengthBytes (32) bytes. /// @note comp_req__kvs__key_length /// /// @param key The key associated with the value to be stored. /// @param value The value to be stored. - /// @return Nothing on success, ErrorCode::InvalidKey if the key is not valid, or another ErrorCode on failure. - score::Result set_value(const std::string_view key, const KvsValue& value) noexcept; + /// @return Nothing on success, ErrorCode::kInvalidKey if the key is not valid, or another ErrorCode on failure. + score::Result SetValue(const std::string_view key, const KvsValue& value) noexcept; /// @brief Removes a key-value pair from the store based on the specified key. /// @param key The key of the key-value pair to be removed. /// @return Nothing on success, or an ErrorCode on failure. - score::Result remove_key(const std::string_view key) noexcept; + score::Result RemoveKey(const std::string_view key) noexcept; /// @brief Removes all key-value pairs from the store. /// @return Nothing on success, or an ErrorCode on failure. - score::Result remove_all_keys() noexcept; + score::Result RemoveAllKeys() noexcept; /// @brief Discards all pending changes to the key-value store. /// - /// Reloads the key-value pairs from storage, dropping every change since the last successful `flush()`. - /// If `flush()` was never called, it drops every change since `open()`. + /// Reloads the key-value pairs from storage, dropping every change since the last successful `Flush()`. + /// If `Flush()` was never called, it drops every change since `Open()`. /// Default values are not affected, since they are read-only for this instance. /// A store that was opened without an existing KVS file and never flushed discards to empty. /// /// @return Nothing on success, or an ErrorCode on failure. - /// Re-reading persisted data can also fail with `KvsHashFileReadError`, `ValidationFailed` or `JsonParserError`. - score::Result discard_pending_changes() noexcept; + /// Re-reading persisted data can also fail with `kKvsHashFileReadError`, `kValidationFailed` or `kJsonParserError`. + score::Result DiscardPendingChanges() noexcept; /// @brief Flushes the key-value store, writing all pending changes to the underlying storage. /// @return Nothing on success, or an ErrorCode on failure. - score::Result flush() noexcept; + score::Result Flush() noexcept; /// @brief Retrieves the number of snapshots currently stored in the key-value store. /// @return The number of snapshots on success, or an ErrorCode on failure. - score::Result snapshot_count() const noexcept; + score::Result SnapshotCount() const noexcept; /// @brief Retrieves the maximum number of snapshots that can be stored. /// - /// The limit is configured per instance via KvsBuilder::snapshot_max_count(). - /// It defaults to KVS_DEFAULT_MAX_SNAPSHOTS and never exceeds KVS_MAX_SNAPSHOTS_UPPER_BOUND. + /// The limit is configured per instance via KvsBuilder::SnapshotMaxCount(). + /// It defaults to kDefaultMaxSnapshots and never exceeds kMaxSnapshotsUpperBound. /// /// @return The maximum number of snapshots. - size_t snapshot_max_count() const noexcept; + size_t SnapshotMaxCount() const noexcept; /// @brief Restores the state of the key-value store from a specified snapshot. /// @param snapshot_id The identifier of the snapshot to restore from. /// @return Nothing on success, or an ErrorCode on failure. - score::Result snapshot_restore(const SnapshotId& snapshot_id) noexcept; + score::Result SnapshotRestore(const SnapshotId& snapshot_id) noexcept; /// @brief Retrieves the filename associated with a given snapshot ID. /// @param snapshot_id The identifier of the snapshot for which the filename is to be retrieved. /// @return The path of the snapshot's KVS file on success, or an ErrorCode on failure. - score::Result get_kvs_filename(const SnapshotId& snapshot_id) const noexcept; + score::Result KvsFilePath(const SnapshotId& snapshot_id) const noexcept; /// @brief Retrieves the filename of the hash file associated with a given snapshot ID. /// @@ -275,18 +311,18 @@ class Kvs final /// /// @param snapshot_id The identifier of the snapshot for which the hash filename is requested. /// @return The path of the snapshot's hash file on success, or an ErrorCode on failure. - score::Result get_hash_filename(const SnapshotId& snapshot_id) const noexcept; + score::Result HashFilePath(const SnapshotId& snapshot_id) const noexcept; /// @brief Retrieves the size of the persisted key-value store on disk. /// /// Returns the combined size in bytes of the current KVS data file and its hash file (snapshot 0). /// Rotated snapshots and the defaults files are not included. - /// The size is read from storage, so it reflects the last successful `flush()` and not pending in-memory changes. + /// The size is read from storage, so it reflects the last successful `Flush()` and not pending in-memory changes. /// A missing file counts as 0 bytes, so a store that was never flushed reports 0 instead of an error. /// /// @return The combined size of both files in bytes on success. - /// `ErrorCode::PhysicalStorageFailure` if a file exists but its size cannot be determined. - score::Result get_storage_file_size() const noexcept; + /// `ErrorCode::kPhysicalStorageFailure` if a file exists but its size cannot be determined. + score::Result GetStorageFileSize() const noexcept; /// @brief Performs a 'dry run' to check if flushing the in-memory store would exceed the storage limit. /// @@ -294,14 +330,164 @@ class Kvs final /// It checks this size against the configured `max_storage_bytes` limit. /// /// @return The estimated total size that the KVS would occupy after a flush on success. - /// `OutOfStorageSpace` if the limit would be exceeded. + /// `kOutOfStorageSpace` if the limit would be exceeded. /// Another ErrorCode for other failures (e.g. serialization). - score::Result calculate_potential_size() const noexcept; + score::Result CalculatePotentialSize() const noexcept; + + // Deprecated snake_case API. + // Each entry forwards to its PascalCase replacement and is removed in a future release. + + /// @deprecated Use `Open()` instead. + [[deprecated("Use Open() instead. This name is removed in a future release.")]] + static score::Result open(const InstanceId& instance_id, + const SnapshotId& snapshot_id, + const KvsDefaults& defaults, + const KvsLoad& kvs_load, + const std::string& working_dir, + const std::optional& max_storage_bytes, + const std::size_t snapshot_max_count) noexcept + { + return Kvs::Open( + instance_id, snapshot_id, defaults, kvs_load, working_dir, max_storage_bytes, snapshot_max_count); + } + + /// @deprecated Use `Reset()` instead. + [[deprecated("Use Reset() instead. This name is removed in a future release.")]] + score::Result reset() noexcept + { + return Reset(); + } + + /// @deprecated Use `GetAllKeys()` instead. + [[deprecated("Use GetAllKeys() instead. This name is removed in a future release.")]] + score::Result> get_all_keys() const noexcept + { + return GetAllKeys(); + } + + /// @deprecated Use `KeyExists()` instead. + [[deprecated("Use KeyExists() instead. This name is removed in a future release.")]] + score::Result key_exists(const std::string_view key) const noexcept + { + return KeyExists(key); + } + + /// @deprecated Use `GetValue()` instead. + [[deprecated("Use GetValue() instead. This name is removed in a future release.")]] + score::Result get_value(const std::string_view key) const noexcept + { + return GetValue(key); + } + + /// @deprecated Use `GetDefaultValue()` instead. + [[deprecated("Use GetDefaultValue() instead. This name is removed in a future release.")]] + score::Result get_default_value(const std::string_view key) const noexcept + { + return GetDefaultValue(key); + } + + /// @deprecated Use `ResetKey()` instead. + [[deprecated("Use ResetKey() instead. This name is removed in a future release.")]] + score::Result reset_key(const std::string_view key) noexcept + { + return ResetKey(key); + } + + /// @deprecated Use `IsValueDefault()` instead. + [[deprecated("Use IsValueDefault() instead. This name is removed in a future release.")]] + score::Result is_value_default(const std::string_view key) const noexcept + { + return IsValueDefault(key); + } + + /// @deprecated Use `SetValue()` instead. + [[deprecated("Use SetValue() instead. This name is removed in a future release.")]] + score::Result set_value(const std::string_view key, const KvsValue& value) noexcept + { + return SetValue(key, value); + } + + /// @deprecated Use `RemoveKey()` instead. + [[deprecated("Use RemoveKey() instead. This name is removed in a future release.")]] + score::Result remove_key(const std::string_view key) noexcept + { + return RemoveKey(key); + } + + /// @deprecated Use `RemoveAllKeys()` instead. + [[deprecated("Use RemoveAllKeys() instead. This name is removed in a future release.")]] + score::Result remove_all_keys() noexcept + { + return RemoveAllKeys(); + } + + /// @deprecated Use `DiscardPendingChanges()` instead. + [[deprecated("Use DiscardPendingChanges() instead. This name is removed in a future release.")]] + score::Result discard_pending_changes() noexcept + { + return DiscardPendingChanges(); + } + + /// @deprecated Use `Flush()` instead. + [[deprecated("Use Flush() instead. This name is removed in a future release.")]] + score::Result flush() noexcept + { + return Flush(); + } + + /// @deprecated Use `SnapshotCount()` instead. + [[deprecated("Use SnapshotCount() instead. This name is removed in a future release.")]] + score::Result snapshot_count() const noexcept + { + return SnapshotCount(); + } + + /// @deprecated Use `SnapshotMaxCount()` instead. + [[deprecated("Use SnapshotMaxCount() instead. This name is removed in a future release.")]] + size_t snapshot_max_count() const noexcept + { + return SnapshotMaxCount(); + } + + /// @deprecated Use `SnapshotRestore()` instead. + [[deprecated("Use SnapshotRestore() instead. This name is removed in a future release.")]] + score::Result snapshot_restore(const SnapshotId& snapshot_id) noexcept + { + return SnapshotRestore(snapshot_id); + } + + /// @deprecated Use `KvsFilePath()` instead. + [[deprecated("Use KvsFilePath() instead. This name is removed in a future release.")]] + score::Result get_kvs_filename(const SnapshotId& snapshot_id) const noexcept + { + return KvsFilePath(snapshot_id); + } + + /// @deprecated Use `HashFilePath()` instead. + [[deprecated("Use HashFilePath() instead. This name is removed in a future release.")]] + score::Result get_hash_filename(const SnapshotId& snapshot_id) const noexcept + { + return HashFilePath(snapshot_id); + } + + /// @deprecated Use `GetStorageFileSize()` instead. + [[deprecated("Use GetStorageFileSize() instead. This name is removed in a future release.")]] + score::Result get_storage_file_size() const noexcept + { + return GetStorageFileSize(); + } + + /// @deprecated Use `CalculatePotentialSize()` instead. + [[deprecated("Use CalculatePotentialSize() instead. This name is removed in a future release.")]] + score::Result calculate_potential_size() const noexcept + { + return CalculatePotentialSize(); + } private: /// @brief Constructs an empty KVS. /// - /// Private to prevent direct instantiation, use open() instead. + /// Private to prevent direct instantiation, use Open() instead. Kvs() noexcept; /// Mutex guarding `kvs_`. @@ -310,7 +496,7 @@ class Kvs final /// Written key-value pairs. KeyValueMap kvs_; - /// Default values, fixed after open(). + /// Default values, fixed after Open(). KeyValueMap default_values_; /// Path prefix of the KVS files, including the instance ID. @@ -337,40 +523,40 @@ class Kvs final std::optional max_storage_bytes_; /// @brief Rotates the snapshots, ensuring that the maximum count is maintained. - score::Result snapshot_rotate() const noexcept; + score::Result SnapshotRotate() const noexcept; /// @brief Parses JSON data into a map of key-value pairs. - score::Result parse_json_data(const std::string& data) const noexcept; + score::Result ParseJsonData(const std::string& data) const noexcept; /// @brief Opens a JSON file, verifies its hash and returns its contents as a map of key-value pairs. - score::Result open_json(const score::filesystem::Path& prefix, - const OpenJsonNeedFile need_file) const noexcept; + score::Result OpenJson(const score::filesystem::Path& prefix, + const OpenJsonNeedFile need_file) const noexcept; /// @brief Writes the provided data to the current JSON file and its hash file. - score::Result write_json_data(const std::string& buf) const noexcept; + score::Result WriteJsonData(const std::string& buf) const noexcept; /// @brief Writes data to the temporary file of a KVS file and ensures it reaches physical storage. /// - /// The live file is not touched, it is replaced by commit_temp_file() once the data is on storage. - score::Result write_temp_file(const score::filesystem::Path& path, - const void* data, - const std::size_t size) const noexcept; + /// The live file is not touched, it is replaced by CommitTempFile() once the data is on storage. + score::Result WriteTempFile(const score::filesystem::Path& path, + const void* data, + const std::size_t size) const noexcept; /// @brief Replaces a KVS file with its temporary file. /// /// The rename is atomic, the file is either old or new. - score::Result commit_temp_file(const score::filesystem::Path& path) const noexcept; + score::Result CommitTempFile(const score::filesystem::Path& path) const noexcept; /// @brief Serializes the KVS and checks the projected total size against the storage limit. - score::Result serialize_and_check() const noexcept; + score::Result SerializeAndCheck() const noexcept; /// @brief Retrieves the size of one file in bytes. /// /// A missing file counts as 0 bytes. - score::Result get_file_size(const score::filesystem::Path& file_path) const noexcept; + score::Result GetFileSize(const score::filesystem::Path& file_path) const noexcept; /// @brief Retrieves the current storage size of all persisted files (defaults and snapshots). - score::Result get_current_storage_size() const noexcept; + score::Result GetCurrentStorageSize() const noexcept; }; } // namespace score::kvs diff --git a/score/kvs/kvs_builder.cpp b/score/kvs/kvs_builder.cpp index 029f34722..89c3857bd 100644 --- a/score/kvs/kvs_builder.cpp +++ b/score/kvs/kvs_builder.cpp @@ -19,57 +19,57 @@ namespace score::kvs KvsBuilder::KvsBuilder(const InstanceId& instance_id) noexcept : instance_id_(instance_id), snapshot_id_(SnapshotId{0}), - need_defaults_(OpenNeedDefaults::Optional), - need_kvs_(OpenNeedKvs::Optional), - directory_("./data_folder/"), + defaults_(KvsDefaults::kOptional), + kvs_load_(score::kvs::KvsLoad::kOptional), + working_dir_("./data_folder/"), maximum_storage_bytes_(std::nullopt), - max_snapshots_(KVS_DEFAULT_MAX_SNAPSHOTS) + max_snapshots_(kDefaultMaxSnapshots) { } -KvsBuilder& KvsBuilder::snapshot(const SnapshotId& snapshot_id) noexcept +KvsBuilder& KvsBuilder::Snapshot(const SnapshotId& snapshot_id) noexcept { this->snapshot_id_ = snapshot_id; return *this; } -KvsBuilder& KvsBuilder::need_defaults_flag(const OpenNeedDefaults& flag) noexcept +KvsBuilder& KvsBuilder::Defaults(const KvsDefaults& mode) noexcept { - need_defaults_ = flag; + defaults_ = mode; return *this; } -KvsBuilder& KvsBuilder::need_kvs_flag(const OpenNeedKvs& flag) noexcept +KvsBuilder& KvsBuilder::KvsLoad(const score::kvs::KvsLoad& mode) noexcept { - need_kvs_ = flag; + kvs_load_ = mode; return *this; } -KvsBuilder& KvsBuilder::dir(const std::string& dir_path) noexcept +KvsBuilder& KvsBuilder::WorkingDir(const std::string& working_dir) noexcept { - this->directory_ = dir_path; + this->working_dir_ = working_dir; return *this; } -KvsBuilder& KvsBuilder::max_storage_bytes(const std::optional& max_storage_bytes) noexcept +KvsBuilder& KvsBuilder::MaxStorageBytes(const std::optional& max_storage_bytes) noexcept { this->maximum_storage_bytes_ = max_storage_bytes; return *this; } -KvsBuilder& KvsBuilder::snapshot_max_count(const std::size_t max_count) noexcept +KvsBuilder& KvsBuilder::SnapshotMaxCount(const std::size_t max_count) noexcept { this->max_snapshots_ = max_count; return *this; } -score::Result KvsBuilder::build() const noexcept +score::Result KvsBuilder::Build() const noexcept { // Use current directory if empty. - const std::string directory = directory_.empty() ? std::string{"./"} : directory_; + const std::string working_dir = working_dir_.empty() ? std::string{"./"} : working_dir_; - return Kvs::open( - instance_id_, snapshot_id_, need_defaults_, need_kvs_, directory, maximum_storage_bytes_, max_snapshots_); + return Kvs::Open( + instance_id_, snapshot_id_, defaults_, kvs_load_, working_dir, maximum_storage_bytes_, max_snapshots_); } } // namespace score::kvs diff --git a/score/kvs/kvs_builder.h b/score/kvs/kvs_builder.h index 2454c8871..4ceb7148a 100644 --- a/score/kvs/kvs_builder.h +++ b/score/kvs/kvs_builder.h @@ -38,19 +38,19 @@ namespace score::kvs /// int main() { /// // Open kvs /// auto open_res = KvsBuilder(0) -/// .need_defaults_flag(OpenNeedDefaults::Required) -/// .need_kvs_flag(OpenNeedKvs::Required) -/// .build(); +/// .Defaults(KvsDefaults::kRequired) +/// .KvsLoad(KvsLoad::kRequired) +/// .Build(); /// if (!open_res) return 1; /// Kvs kvs = std::move(open_res.value()); /// /// // Set and get a value -/// kvs.set_value("pi", KvsValue(3.14)); -/// auto get_res = kvs.get_value("pi"); +/// kvs.SetValue("pi", KvsValue(3.14)); +/// auto get_res = kvs.GetValue("pi"); /// /// // Delete a key -/// kvs.remove_key("pi"); -/// std::cout << "has pi? " << (kvs.key_exists("pi").value_or(false) ? "yes" : "no") << "\n"; +/// kvs.RemoveKey("pi"); +/// std::cout << "has pi? " << (kvs.KeyExists("pi").value_or(false) ? "yes" : "no") << "\n"; /// /// return 0; /// } @@ -65,49 +65,101 @@ class KvsBuilder final /// @brief Specifies the snapshot identifier to be loaded. /// @param snapshot_id Unique identifier for the KVS snapshot. /// @return Reference to this builder (for chaining). - KvsBuilder& snapshot(const SnapshotId& snapshot_id) noexcept; + KvsBuilder& Snapshot(const SnapshotId& snapshot_id) noexcept; /// @brief Specifies whether default values must be loaded. - /// @param flag Whether default values are required, optional or ignored. + /// @param mode Whether default values are required, optional or ignored. /// @return Reference to this builder (for chaining). - KvsBuilder& need_defaults_flag(const OpenNeedDefaults& flag) noexcept; + KvsBuilder& Defaults(const KvsDefaults& mode) noexcept; /// @brief Specifies whether KVS data must exist when opening the KVS. - /// @param flag Whether KVS data is required, optional or ignored. + /// @param mode Whether KVS data is required, optional or ignored. /// @return Reference to this builder (for chaining). - KvsBuilder& need_kvs_flag(const OpenNeedKvs& flag) noexcept; + KvsBuilder& KvsLoad(const score::kvs::KvsLoad& mode) noexcept; /// @brief Specifies the directory where KVS files are stored. - /// @param dir_path The directory path. + /// @param working_dir The directory path. /// Use "" or "." for the current directory. /// @return Reference to this builder (for chaining). - KvsBuilder& dir(const std::string& dir_path) noexcept; + KvsBuilder& WorkingDir(const std::string& working_dir) noexcept; /// @brief Specifies the maximum storage size for the KVS in bytes. /// @param max_storage_bytes The maximum allowed total storage size in bytes. /// When this option is not used, no storage limit is enforced. /// @return Reference to this builder (for chaining). - KvsBuilder& max_storage_bytes(const std::optional& max_storage_bytes) noexcept; + KvsBuilder& MaxStorageBytes(const std::optional& max_storage_bytes) noexcept; /// @brief Specifies the maximum number of snapshots the KVS maintains. /// - /// The maximum number of snapshots is configurable per instance in the range 0..KVS_MAX_SNAPSHOTS_UPPER_BOUND. - /// When this option is not used, KVS_DEFAULT_MAX_SNAPSHOTS is applied. + /// The maximum number of snapshots is configurable per instance in the range 0..kMaxSnapshotsUpperBound. + /// When this option is not used, kDefaultMaxSnapshots is applied. /// @note comp_req__kvs__snapshot_max_num_cfg /// /// @param max_count Maximum number of snapshots. - /// Values above KVS_MAX_SNAPSHOTS_UPPER_BOUND are clamped to it when the KVS is built. + /// Values above kMaxSnapshotsUpperBound are clamped to it when the KVS is built. /// A value of 0 disables snapshot operations. - /// flush() still persists the current KVS data. + /// Flush() still persists the current KVS data. /// @return Reference to this builder (for chaining). - KvsBuilder& snapshot_max_count(const std::size_t max_count) noexcept; + KvsBuilder& SnapshotMaxCount(const std::size_t max_count) noexcept; /// @brief Builds and opens the Kvs instance with the configured options. /// - /// Internally calls Kvs::open() with the selected flags and directory. + /// Internally calls Kvs::Open() with the selected flags and directory. /// /// @return The opened store on success, or an ErrorCode on failure. - score::Result build() const noexcept; + score::Result Build() const noexcept; + + // Deprecated snake_case API. + // Each entry forwards to its PascalCase replacement and is removed in a future release. + + /// @deprecated Use `Snapshot()` instead. + [[deprecated("Use Snapshot() instead. This name is removed in a future release.")]] + KvsBuilder& snapshot(const SnapshotId& snapshot_id) noexcept + { + return Snapshot(snapshot_id); + } + + /// @deprecated Use `Defaults()` instead. + [[deprecated("Use Defaults() instead. This name is removed in a future release.")]] + KvsBuilder& need_defaults_flag(const KvsDefaults& flag) noexcept + { + return Defaults(flag); + } + + /// @deprecated Use `KvsLoad()` instead. + [[deprecated("Use KvsLoad() instead. This name is removed in a future release.")]] + KvsBuilder& need_kvs_flag(const score::kvs::KvsLoad& flag) noexcept + { + return KvsLoad(flag); + } + + /// @deprecated Use `WorkingDir()` instead. + [[deprecated("Use WorkingDir() instead. This name is removed in a future release.")]] + KvsBuilder& dir(const std::string& dir_path) noexcept + { + return WorkingDir(dir_path); + } + + /// @deprecated Use `MaxStorageBytes()` instead. + [[deprecated("Use MaxStorageBytes() instead. This name is removed in a future release.")]] + KvsBuilder& max_storage_bytes(const std::optional& max_storage_bytes) noexcept + { + return MaxStorageBytes(max_storage_bytes); + } + + /// @deprecated Use `SnapshotMaxCount()` instead. + [[deprecated("Use SnapshotMaxCount() instead. This name is removed in a future release.")]] + KvsBuilder& snapshot_max_count(const std::size_t max_count) noexcept + { + return SnapshotMaxCount(max_count); + } + + /// @deprecated Use `Build()` instead. + [[deprecated("Use Build() instead. This name is removed in a future release.")]] + score::Result build() const noexcept + { + return Build(); + } private: /// ID of the KVS instance. @@ -117,13 +169,13 @@ class KvsBuilder final SnapshotId snapshot_id_; /// Whether default values are required. - OpenNeedDefaults need_defaults_; + KvsDefaults defaults_; /// Whether an existing KVS is required. - OpenNeedKvs need_kvs_; + score::kvs::KvsLoad kvs_load_; /// Directory where the KVS files are stored. - std::string directory_; + std::string working_dir_; /// Maximum total storage size in bytes. /// Unset means no limit. diff --git a/score/kvs/kvs_builder_test.cpp b/score/kvs/kvs_builder_test.cpp index 549fde6a0..4cd530a0d 100644 --- a/score/kvs/kvs_builder_test.cpp +++ b/score/kvs/kvs_builder_test.cpp @@ -15,114 +15,114 @@ TEST(kvs_kvsbuilder, kvsbuilder_build_ignored) { - KvsBuilder builder(instance_id); - builder.snapshot(SnapshotId{0ul}); - builder.need_defaults_flag(OpenNeedDefaults::Ignored); - builder.need_kvs_flag(OpenNeedKvs::Ignored); - builder.dir("./kvsbuilder/"); - EXPECT_EQ(builder.instance_id_.id, instance_id.id); + KvsBuilder builder(kInstanceId); + builder.Snapshot(SnapshotId{0ul}); + builder.Defaults(KvsDefaults::kIgnored); + builder.KvsLoad(KvsLoad::kIgnored); + builder.WorkingDir("./kvsbuilder/"); + EXPECT_EQ(builder.instance_id_.id, kInstanceId.id); EXPECT_EQ(builder.snapshot_id_.id, 0ul); - EXPECT_EQ(builder.need_defaults_, OpenNeedDefaults::Ignored); - EXPECT_EQ(builder.need_kvs_, OpenNeedKvs::Ignored); - EXPECT_EQ(builder.directory_, "./kvsbuilder/"); + EXPECT_EQ(builder.defaults_, KvsDefaults::kIgnored); + EXPECT_EQ(builder.kvs_load_, KvsLoad::kIgnored); + EXPECT_EQ(builder.working_dir_, "./kvsbuilder/"); - auto result_build = builder.build(); + auto result_build = builder.Build(); EXPECT_TRUE(result_build); - EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvsbuilder/kvs_" + std::to_string(instance_id.id)); + EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvsbuilder/kvs_" + std::to_string(kInstanceId.id)); } TEST(kvs_kvsbuilder, kvsbuilder_build) { - // This test also checks the kvs open function with the KvsBuilder. + // This test also checks the kvs Open function with the KvsBuilder. // Test the KvsBuilder constructor. - KvsBuilder builder(instance_id); - EXPECT_EQ(builder.instance_id_.id, instance_id.id); + KvsBuilder builder(kInstanceId); + EXPECT_EQ(builder.instance_id_.id, kInstanceId.id); EXPECT_EQ(builder.snapshot_id_.id, 0ul); - EXPECT_EQ(builder.need_defaults_, OpenNeedDefaults::Optional); - EXPECT_EQ(builder.need_kvs_, OpenNeedKvs::Optional); + EXPECT_EQ(builder.defaults_, KvsDefaults::kOptional); + EXPECT_EQ(builder.kvs_load_, KvsLoad::kOptional); // Test the KvsBuilder methods. - builder.snapshot(SnapshotId{23ul}); + builder.Snapshot(SnapshotId{23ul}); EXPECT_EQ(builder.snapshot_id_.id, 23ul); - builder.need_defaults_flag(OpenNeedDefaults::Required); - EXPECT_EQ(builder.need_defaults_, OpenNeedDefaults::Required); - builder.need_kvs_flag(OpenNeedKvs::Required); - EXPECT_EQ(builder.need_kvs_, OpenNeedKvs::Required); - builder.dir("./kvsbuilder/"); - EXPECT_EQ(builder.directory_, "./kvsbuilder/"); - - // Test the KvsBuilder build method. - // Check that OpenNeedDefaults::Required and OpenNeedKvs::Required are passed correctly. - // build() should return an error, since the files are not available. - auto result_build = builder.build(); + builder.Defaults(KvsDefaults::kRequired); + EXPECT_EQ(builder.defaults_, KvsDefaults::kRequired); + builder.KvsLoad(KvsLoad::kRequired); + EXPECT_EQ(builder.kvs_load_, KvsLoad::kRequired); + builder.WorkingDir("./kvsbuilder/"); + EXPECT_EQ(builder.working_dir_, "./kvsbuilder/"); + + // Test the KvsBuilder Build method. + // Check that KvsDefaults::kRequired and KvsLoad::kRequired are passed correctly. + // Build() should return an error, since the files are not available. + auto result_build = builder.Build(); ASSERT_FALSE(result_build); - // This error occurs in open_json() and is passed through open(). - EXPECT_EQ(static_cast(*result_build.error()), ErrorCode::KvsFileReadError); - builder.need_defaults_flag(OpenNeedDefaults::Optional); - result_build = builder.build(); + // This error occurs in OpenJson() and is passed through Open(). + EXPECT_EQ(static_cast(*result_build.error()), ErrorCode::kKvsFileReadError); + builder.Defaults(KvsDefaults::kOptional); + result_build = builder.Build(); ASSERT_FALSE(result_build); - // This error occurs in open_json() and is passed through open(). - EXPECT_EQ(static_cast(*result_build.error()), ErrorCode::KvsFileReadError); - builder.need_kvs_flag(OpenNeedKvs::Optional); - result_build = builder.build(); + // This error occurs in OpenJson() and is passed through Open(). + EXPECT_EQ(static_cast(*result_build.error()), ErrorCode::kKvsFileReadError); + builder.KvsLoad(KvsLoad::kOptional); + result_build = builder.Build(); EXPECT_TRUE(result_build); - EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvsbuilder/kvs_" + std::to_string(instance_id.id)); + EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvsbuilder/kvs_" + std::to_string(kInstanceId.id)); } TEST(kvs_kvsbuilder, kvsbuilder_directory_check) { // Test the KvsBuilder with all configurations for the current working directory. - KvsBuilder builder(instance_id); - builder.dir(""); - auto result_build = builder.build(); + KvsBuilder builder(kInstanceId); + builder.WorkingDir(""); + auto result_build = builder.Build(); EXPECT_TRUE(result_build); - EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvs_" + std::to_string(instance_id.id)); + EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvs_" + std::to_string(kInstanceId.id)); - builder.dir("./"); - result_build = builder.build(); + builder.WorkingDir("./"); + result_build = builder.Build(); EXPECT_TRUE(result_build); - EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvs_" + std::to_string(instance_id.id)); + EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvs_" + std::to_string(kInstanceId.id)); - builder.dir("."); - result_build = builder.build(); + builder.WorkingDir("."); + result_build = builder.Build(); EXPECT_TRUE(result_build); - EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvs_" + std::to_string(instance_id.id)); + EXPECT_EQ(result_build.value().filename_prefix_.CStr(), "./kvs_" + std::to_string(kInstanceId.id)); } TEST(kvs_kvsbuilder, kvsbuilder_snapshot_max_count_default) { // comp_req__kvs__snapshot_max_num_cfg: an unconfigured builder must keep the compile-time default. // Existing users then observe no behavior change. - KvsBuilder builder(instance_id); - EXPECT_EQ(builder.max_snapshots_, KVS_DEFAULT_MAX_SNAPSHOTS); + KvsBuilder builder(kInstanceId); + EXPECT_EQ(builder.max_snapshots_, kDefaultMaxSnapshots); - builder.dir(std::string(data_dir)); - auto result_build = builder.build(); + builder.WorkingDir(std::string(kDataDir)); + auto result_build = builder.Build(); ASSERT_TRUE(result_build); - EXPECT_EQ(result_build.value().snapshot_max_count(), KVS_DEFAULT_MAX_SNAPSHOTS); + EXPECT_EQ(result_build.value().SnapshotMaxCount(), kDefaultMaxSnapshots); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_kvsbuilder, kvsbuilder_snapshot_max_count_configured) { // comp_req__kvs__snapshot_max_num_cfg: the configured value must reach the built KVS instance. - // Without the plumbing through build()/open() the setter would be silently ignored. + // Without the plumbing through Build()/Open() the setter would be silently ignored. // Inside the allowed range, and not the default. const std::size_t configured_max = 2U; - KvsBuilder builder(instance_id); - builder.snapshot_max_count(configured_max); + KvsBuilder builder(kInstanceId); + builder.SnapshotMaxCount(configured_max); EXPECT_EQ(builder.max_snapshots_, configured_max); // The setter must be chainable like every other builder option. - EXPECT_EQ(&builder.snapshot_max_count(configured_max), &builder); + EXPECT_EQ(&builder.SnapshotMaxCount(configured_max), &builder); - builder.dir(std::string(data_dir)); - auto result_build = builder.build(); + builder.WorkingDir(std::string(kDataDir)); + auto result_build = builder.Build(); ASSERT_TRUE(result_build); - EXPECT_EQ(result_build.value().snapshot_max_count(), configured_max); + EXPECT_EQ(result_build.value().SnapshotMaxCount(), configured_max); - cleanup_environment(); + CleanupEnvironment(); } diff --git a/score/kvs/kvs_deprecated_api_test.cpp b/score/kvs/kvs_deprecated_api_test.cpp new file mode 100644 index 000000000..ac72fb173 --- /dev/null +++ b/score/kvs/kvs_deprecated_api_test.cpp @@ -0,0 +1,339 @@ +/******************************************************************************** + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Apache License Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + ********************************************************************************/ + +#include "score/kvs/kvs_general_test.h" + +#include "score/quality/compiler_warnings/warnings.h" +#include + +// The old headers warn inside the header, so the suppression surrounds the includes. +// clang-format off +DISABLE_WARNING_PUSH +DISABLE_WARNING(-Wdeprecated-declarations) +// clang-format on +#include "score/kvs/error.hpp" +#include "score/kvs/kvs.hpp" +#include "score/kvs/kvsbuilder.hpp" +#include "score/kvs/kvsvalue.hpp" +DISABLE_WARNING_POP + +namespace +{ + +// The ErrorCode values reach logs and tests through static_cast, so they must stay unchanged. +static_assert(static_cast(ErrorCode::kUnmappedError) == 0, ""); +static_assert(static_cast(ErrorCode::kFileNotFound) == 1, ""); +static_assert(static_cast(ErrorCode::kKvsFileReadError) == 2, ""); +static_assert(static_cast(ErrorCode::kKvsHashFileReadError) == 3, ""); +static_assert(static_cast(ErrorCode::kJsonParserError) == 4, ""); +static_assert(static_cast(ErrorCode::kJsonGeneratorError) == 5, ""); +static_assert(static_cast(ErrorCode::kPhysicalStorageFailure) == 6, ""); +static_assert(static_cast(ErrorCode::kIntegrityCorrupted) == 7, ""); +static_assert(static_cast(ErrorCode::kValidationFailed) == 8, ""); +static_assert(static_cast(ErrorCode::kEncryptionFailed) == 9, ""); +static_assert(static_cast(ErrorCode::kResourceBusy) == 10, ""); +static_assert(static_cast(ErrorCode::kOutOfStorageSpace) == 11, ""); +static_assert(static_cast(ErrorCode::kQuotaExceeded) == 12, ""); +static_assert(static_cast(ErrorCode::kAuthenticationFailed) == 13, ""); +static_assert(static_cast(ErrorCode::kKeyNotFound) == 14, ""); +static_assert(static_cast(ErrorCode::kKeyDefaultNotFound) == 15, ""); +static_assert(static_cast(ErrorCode::kSerializationFailed) == 16, ""); +static_assert(static_cast(ErrorCode::kInvalidSnapshotId) == 17, ""); +static_assert(static_cast(ErrorCode::kConversionFailed) == 18, ""); +static_assert(static_cast(ErrorCode::kMutexLockFailed) == 19, ""); +static_assert(static_cast(ErrorCode::kInvalidValueType) == 20, ""); +static_assert(static_cast(ErrorCode::kInvalidKey) == 21, ""); + +// Each deprecated name has the value of its replacement. +// clang-format off +DISABLE_WARNING_PUSH +DISABLE_WARNING(-Wdeprecated-declarations) +// clang-format on +static_assert(KVS_MAX_KEY_LENGTH_BYTES == kMaxKeyLengthBytes, ""); +static_assert(KVS_MAX_SNAPSHOTS_UPPER_BOUND == kMaxSnapshotsUpperBound, ""); +static_assert(KVS_DEFAULT_MAX_SNAPSHOTS == kDefaultMaxSnapshots, ""); +static_assert(OpenNeedDefaults::Required == KvsDefaults::kRequired, ""); +static_assert(OpenNeedDefaults::Optional == KvsDefaults::kOptional, ""); +static_assert(OpenNeedDefaults::Ignored == KvsDefaults::kIgnored, ""); +static_assert(OpenNeedKvs::Required == KvsLoad::kRequired, ""); +static_assert(OpenNeedKvs::Optional == KvsLoad::kOptional, ""); +static_assert(OpenNeedKvs::Ignored == KvsLoad::kIgnored, ""); +static_assert(std::is_same_v, ""); +static_assert(std::is_same_v, ""); +static_assert(OpenJsonNeedFile::Required == OpenJsonNeedFile::kRequired, ""); +static_assert(OpenJsonNeedFile::Optional == OpenJsonNeedFile::kOptional, ""); +static_assert(KvsValue::Type::i32 == KvsValue::Type::kI32, ""); +static_assert(KvsValue::Type::u32 == KvsValue::Type::kU32, ""); +static_assert(KvsValue::Type::i64 == KvsValue::Type::kI64, ""); +static_assert(KvsValue::Type::u64 == KvsValue::Type::kU64, ""); +static_assert(KvsValue::Type::f64 == KvsValue::Type::kF64, ""); +static_assert(KvsValue::Type::Boolean == KvsValue::Type::kBoolean, ""); +static_assert(KvsValue::Type::String == KvsValue::Type::kString, ""); +static_assert(KvsValue::Type::Null == KvsValue::Type::kNull, ""); +static_assert(KvsValue::Type::Array == KvsValue::Type::kArray, ""); +static_assert(KvsValue::Type::Object == KvsValue::Type::kObject, ""); +static_assert(ErrorCode::UnmappedError == ErrorCode::kUnmappedError, ""); +static_assert(ErrorCode::FileNotFound == ErrorCode::kFileNotFound, ""); +static_assert(ErrorCode::KvsFileReadError == ErrorCode::kKvsFileReadError, ""); +static_assert(ErrorCode::KvsHashFileReadError == ErrorCode::kKvsHashFileReadError, ""); +static_assert(ErrorCode::JsonParserError == ErrorCode::kJsonParserError, ""); +static_assert(ErrorCode::JsonGeneratorError == ErrorCode::kJsonGeneratorError, ""); +static_assert(ErrorCode::PhysicalStorageFailure == ErrorCode::kPhysicalStorageFailure, ""); +static_assert(ErrorCode::IntegrityCorrupted == ErrorCode::kIntegrityCorrupted, ""); +static_assert(ErrorCode::ValidationFailed == ErrorCode::kValidationFailed, ""); +static_assert(ErrorCode::EncryptionFailed == ErrorCode::kEncryptionFailed, ""); +static_assert(ErrorCode::ResourceBusy == ErrorCode::kResourceBusy, ""); +static_assert(ErrorCode::OutOfStorageSpace == ErrorCode::kOutOfStorageSpace, ""); +static_assert(ErrorCode::QuotaExceeded == ErrorCode::kQuotaExceeded, ""); +static_assert(ErrorCode::AuthenticationFailed == ErrorCode::kAuthenticationFailed, ""); +static_assert(ErrorCode::KeyNotFound == ErrorCode::kKeyNotFound, ""); +static_assert(ErrorCode::KeyDefaultNotFound == ErrorCode::kKeyDefaultNotFound, ""); +static_assert(ErrorCode::SerializationFailed == ErrorCode::kSerializationFailed, ""); +static_assert(ErrorCode::InvalidSnapshotId == ErrorCode::kInvalidSnapshotId, ""); +static_assert(ErrorCode::ConversionFailed == ErrorCode::kConversionFailed, ""); +static_assert(ErrorCode::MutexLockFailed == ErrorCode::kMutexLockFailed, ""); +static_assert(ErrorCode::InvalidValueType == ErrorCode::kInvalidValueType, ""); +static_assert(ErrorCode::InvalidKey == ErrorCode::kInvalidKey, ""); +DISABLE_WARNING_POP + +score::Result OpenKvs() +{ + return Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), + std::nullopt, + kDefaultMaxSnapshots); +} + +void ExpectSame(const score::Result& old_result, const score::Result& new_result) +{ + ASSERT_EQ(old_result.has_value(), new_result.has_value()); + if (!old_result.has_value()) + { + EXPECT_EQ(*old_result.error(), *new_result.error()); + } +} + +} // namespace + +TEST(kvs_deprecated_api, kvs_open) +{ + PrepareEnvironment(); + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + auto result = Kvs::open(kInstanceId, + kSnapshotId, + OpenNeedDefaults::kOptional, + OpenNeedKvs::kOptional, + std::string(kDataDir), + std::nullopt, + kDefaultMaxSnapshots); + DISABLE_WARNING_POP + auto new_result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), + std::nullopt, + kDefaultMaxSnapshots); + ASSERT_TRUE(result); + ASSERT_TRUE(new_result); + EXPECT_EQ(result.value().GetAllKeys().value(), new_result.value().GetAllKeys().value()); + EXPECT_EQ(result.value().SnapshotMaxCount(), new_result.value().SnapshotMaxCount()); + EXPECT_STREQ(result.value().KvsFilePath(kSnapshotId).value().CStr(), + new_result.value().KvsFilePath(kSnapshotId).value().CStr()); + CleanupEnvironment(); +} + +TEST(kvs_deprecated_api, kvs_read_wrappers) +{ + PrepareEnvironment(); + auto result = OpenKvs(); + ASSERT_TRUE(result); + Kvs& kvs = result.value(); + + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + auto old_keys = kvs.get_all_keys(); + auto old_exists = kvs.key_exists("kvs"); + auto old_missing = kvs.key_exists("missing"); + auto old_value = kvs.get_value("kvs"); + auto old_default = kvs.get_default_value("default"); + auto old_is_default = kvs.is_value_default("default"); + auto old_count = kvs.snapshot_count(); + const size_t old_max_count = kvs.snapshot_max_count(); + auto old_kvs_filename = kvs.get_kvs_filename(kSnapshotId); + auto old_hash_filename = kvs.get_hash_filename(kSnapshotId); + auto old_file_size = kvs.get_storage_file_size(); + auto old_potential_size = kvs.calculate_potential_size(); + DISABLE_WARNING_POP + + auto new_keys = kvs.GetAllKeys(); + ASSERT_TRUE(old_keys); + ASSERT_TRUE(new_keys); + EXPECT_EQ(old_keys.value(), new_keys.value()); + + EXPECT_EQ(old_exists.value(), kvs.KeyExists("kvs").value()); + EXPECT_EQ(old_missing.value(), kvs.KeyExists("missing").value()); + + ASSERT_TRUE(old_value); + EXPECT_EQ(old_value.value().GetType(), kvs.GetValue("kvs").value().GetType()); + EXPECT_EQ(std::get(old_value.value().GetValue()), + std::get(kvs.GetValue("kvs").value().GetValue())); + + ASSERT_TRUE(old_default); + EXPECT_EQ(std::get(old_default.value().GetValue()), + std::get(kvs.GetDefaultValue("default").value().GetValue())); + + EXPECT_EQ(old_is_default.value(), kvs.IsValueDefault("default").value()); + EXPECT_EQ(old_count.value(), kvs.SnapshotCount().value()); + EXPECT_EQ(old_max_count, kvs.SnapshotMaxCount()); + EXPECT_STREQ(old_kvs_filename.value().CStr(), kvs.KvsFilePath(kSnapshotId).value().CStr()); + EXPECT_STREQ(old_hash_filename.value().CStr(), kvs.HashFilePath(kSnapshotId).value().CStr()); + EXPECT_EQ(old_file_size.value(), kvs.GetStorageFileSize().value()); + EXPECT_EQ(old_potential_size.value(), kvs.CalculatePotentialSize().value()); + CleanupEnvironment(); +} + +TEST(kvs_deprecated_api, kvs_write_wrappers) +{ + PrepareEnvironment(); + auto result = OpenKvs(); + ASSERT_TRUE(result); + Kvs& kvs = result.value(); + + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + // Each old wrapper is called once and its effect is checked, so that a wrapper forwarding elsewhere is caught. + ExpectSame(kvs.set_value("old_key", KvsValue(1)), kvs.SetValue("new_key", KvsValue(1))); + EXPECT_EQ(std::get(kvs.GetValue("old_key").value().GetValue()), 1); + EXPECT_EQ(std::get(kvs.GetValue("new_key").value().GetValue()), 1); + + ASSERT_TRUE(kvs.SetValue("default", KvsValue(9))); + ASSERT_FALSE(kvs.IsValueDefault("default").value()); + ASSERT_TRUE(kvs.reset_key("default")); + EXPECT_TRUE(kvs.IsValueDefault("default").value()); + + ASSERT_TRUE(kvs.remove_key("old_key")); + EXPECT_FALSE(kvs.KeyExists("old_key").value()); + EXPECT_TRUE(kvs.KeyExists("new_key").value()); + + // A flushed key is visible to a KVS opened afterwards. + ASSERT_TRUE(kvs.flush()); + auto reopened = OpenKvs(); + ASSERT_TRUE(reopened); + EXPECT_TRUE(reopened.value().KeyExists("new_key").value()); + EXPECT_TRUE(reopened.value().KeyExists("kvs").value()); + + // Pending changes are dropped, flushed ones stay. + ASSERT_TRUE(kvs.SetValue("pending", KvsValue(3))); + ASSERT_TRUE(kvs.discard_pending_changes()); + EXPECT_FALSE(kvs.KeyExists("pending").value()); + EXPECT_TRUE(kvs.KeyExists("new_key").value()); + EXPECT_TRUE(kvs.KeyExists("kvs").value()); + + ASSERT_TRUE(kvs.remove_all_keys()); + EXPECT_TRUE(kvs.GetAllKeys().value().empty()); + + ASSERT_TRUE(kvs.SetValue("again", KvsValue(4))); + ASSERT_TRUE(kvs.reset()); + EXPECT_TRUE(kvs.GetAllKeys().value().empty()); + + auto old_restore_ok = kvs.snapshot_restore(SnapshotId{0ul}); + auto new_restore_ok = kvs.SnapshotRestore(SnapshotId{0ul}); + ExpectSame(old_restore_ok, new_restore_ok); + auto old_restore_bad = kvs.snapshot_restore(SnapshotId{99ul}); + auto new_restore_bad = kvs.SnapshotRestore(SnapshotId{99ul}); + ExpectSame(old_restore_bad, new_restore_bad); + DISABLE_WARNING_POP + CleanupEnvironment(); +} + +TEST(kvs_deprecated_api, kvsbuilder_wrappers) +{ + PrepareEnvironment(); + + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + KvsBuilder old_builder(kInstanceId); + old_builder.snapshot(SnapshotId{23ul}) + .need_defaults_flag(OpenNeedDefaults::kRequired) + .need_kvs_flag(OpenNeedKvs::kRequired) + .dir("./kvsbuilder/") + .max_storage_bytes(std::optional{1024ul}) + .snapshot_max_count(2ul); + + KvsBuilder new_builder(kInstanceId); + new_builder.Snapshot(SnapshotId{23ul}) + .Defaults(KvsDefaults::kRequired) + .KvsLoad(KvsLoad::kRequired) + .WorkingDir("./kvsbuilder/") + .MaxStorageBytes(std::optional{1024ul}) + .SnapshotMaxCount(2ul); + DISABLE_WARNING_POP + + EXPECT_EQ(old_builder.snapshot_id_.id, new_builder.snapshot_id_.id); + EXPECT_EQ(old_builder.defaults_, new_builder.defaults_); + EXPECT_EQ(old_builder.kvs_load_, new_builder.kvs_load_); + EXPECT_EQ(old_builder.working_dir_, new_builder.working_dir_); + EXPECT_EQ(old_builder.maximum_storage_bytes_, new_builder.maximum_storage_bytes_); + EXPECT_EQ(old_builder.max_snapshots_, new_builder.max_snapshots_); + + // Both builders fail the same way, since the required files are not available. + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + auto old_result = old_builder.build(); + DISABLE_WARNING_POP + auto new_result = new_builder.Build(); + ASSERT_FALSE(old_result); + ASSERT_FALSE(new_result); + EXPECT_EQ(*old_result.error(), *new_result.error()); + + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + auto success = KvsBuilder(kInstanceId).dir(std::string(kDataDir)).build(); + DISABLE_WARNING_POP + auto new_success = KvsBuilder(kInstanceId).WorkingDir(std::string(kDataDir)).Build(); + ASSERT_TRUE(success); + ASSERT_TRUE(new_success); + EXPECT_EQ(success.value().GetAllKeys().value(), new_success.value().GetAllKeys().value()); + EXPECT_EQ(success.value().SnapshotMaxCount(), new_success.value().SnapshotMaxCount()); + CleanupEnvironment(); +} + +TEST(kvs_deprecated_api, kvsvalue_wrappers) +{ + const KvsValue value(42); + + // clang-format off + DISABLE_WARNING_PUSH + DISABLE_WARNING(-Wdeprecated-declarations) + // clang-format on + EXPECT_EQ(value.getType(), value.GetType()); + EXPECT_EQ(std::get(value.getValue()), std::get(value.GetValue())); + DISABLE_WARNING_POP +} diff --git a/score/kvs/kvs_error_test.cpp b/score/kvs/kvs_error_test.cpp index ec86fced9..839b9b34f 100644 --- a/score/kvs/kvs_error_test.cpp +++ b/score/kvs/kvs_error_test.cpp @@ -15,7 +15,7 @@ namespace { -constexpr score::kvs::KvsErrorDomain kvs_error_domain; +constexpr score::kvs::KvsErrorDomain kKvsErrorDomain; } TEST(kvs_MessageFor, MessageFor) @@ -25,36 +25,36 @@ TEST(kvs_MessageFor, MessageFor) ErrorCode code; std::string_view expected_message; } test_cases[] = { - {ErrorCode::UnmappedError, "Error that was not yet mapped"}, - {ErrorCode::FileNotFound, "File not found"}, - {ErrorCode::KvsFileReadError, "KVS file read error"}, - {ErrorCode::KvsHashFileReadError, "KVS hash file read error"}, - {ErrorCode::JsonParserError, "JSON parser error"}, - {ErrorCode::JsonGeneratorError, "JSON generator error"}, - {ErrorCode::PhysicalStorageFailure, "Physical storage failure"}, - {ErrorCode::IntegrityCorrupted, "Integrity corrupted"}, - {ErrorCode::ValidationFailed, "Validation failed"}, - {ErrorCode::EncryptionFailed, "Encryption failed"}, - {ErrorCode::ResourceBusy, "Resource is busy"}, - {ErrorCode::OutOfStorageSpace, "Out of storage space"}, - {ErrorCode::QuotaExceeded, "Quota exceeded"}, - {ErrorCode::AuthenticationFailed, "Authentication failed"}, - {ErrorCode::KeyNotFound, "Key not found"}, - {ErrorCode::KeyDefaultNotFound, "Key default value not found"}, - {ErrorCode::SerializationFailed, "Serialization failed"}, - {ErrorCode::InvalidSnapshotId, "Invalid snapshot ID"}, - {ErrorCode::ConversionFailed, "Conversion failed"}, - {ErrorCode::MutexLockFailed, "Mutex failed"}, - {ErrorCode::InvalidValueType, "Invalid value type"}, - {ErrorCode::InvalidKey, "Key is not valid"}, + {ErrorCode::kUnmappedError, "Error that was not yet mapped"}, + {ErrorCode::kFileNotFound, "File not found"}, + {ErrorCode::kKvsFileReadError, "KVS file read error"}, + {ErrorCode::kKvsHashFileReadError, "KVS hash file read error"}, + {ErrorCode::kJsonParserError, "JSON parser error"}, + {ErrorCode::kJsonGeneratorError, "JSON generator error"}, + {ErrorCode::kPhysicalStorageFailure, "Physical storage failure"}, + {ErrorCode::kIntegrityCorrupted, "Integrity corrupted"}, + {ErrorCode::kValidationFailed, "Validation failed"}, + {ErrorCode::kEncryptionFailed, "Encryption failed"}, + {ErrorCode::kResourceBusy, "Resource is busy"}, + {ErrorCode::kOutOfStorageSpace, "Out of storage space"}, + {ErrorCode::kQuotaExceeded, "Quota exceeded"}, + {ErrorCode::kAuthenticationFailed, "Authentication failed"}, + {ErrorCode::kKeyNotFound, "Key not found"}, + {ErrorCode::kKeyDefaultNotFound, "Key default value not found"}, + {ErrorCode::kSerializationFailed, "Serialization failed"}, + {ErrorCode::kInvalidSnapshotId, "Invalid snapshot ID"}, + {ErrorCode::kConversionFailed, "Conversion failed"}, + {ErrorCode::kMutexLockFailed, "Mutex failed"}, + {ErrorCode::kInvalidValueType, "Invalid value type"}, + {ErrorCode::kInvalidKey, "Key is not valid"}, }; for (const auto& test : test_cases) { SCOPED_TRACE(static_cast(test.code)); score::result::ErrorCode code = static_cast(test.code); - EXPECT_EQ(kvs_error_domain.MessageFor(code), test.expected_message); + EXPECT_EQ(kKvsErrorDomain.MessageFor(code), test.expected_message); } score::result::ErrorCode invalid_code = static_cast(9999); - EXPECT_EQ(kvs_error_domain.MessageFor(invalid_code), "Unknown Error!"); + EXPECT_EQ(kKvsErrorDomain.MessageFor(invalid_code), "Unknown Error!"); } diff --git a/score/kvs/kvs_general_test.cpp b/score/kvs/kvs_general_test.cpp index 88491d090..98ac426cc 100644 --- a/score/kvs/kvs_general_test.cpp +++ b/score/kvs/kvs_general_test.cpp @@ -14,7 +14,7 @@ #include "score/kvs/kvs_general_test.h" /// @brief Independent Adler-32 implementation to check the KVS hash against. -uint32_t adler32(const std::string& data) +uint32_t Adler32(const std::string& data) { const uint32_t mod = 65521; uint32_t a = 1, b = 0; @@ -26,49 +26,49 @@ uint32_t adler32(const std::string& data) return (b << 16) | a; } -void store(const std::string& filePath, const std::string& hashPath, const std::string& data) +void Store(const std::string& file_path, const std::string& hash_path, const std::string& data) { - const uint32_t dataHash{adler32(data)}; + const uint32_t data_hash{Adler32(data)}; - std::ofstream file(filePath); + std::ofstream file(file_path); if (file.is_open()) { file << data; file.close(); } - std::ofstream hashFile(hashPath, std::ios::binary); - if (hashFile.is_open()) + std::ofstream hash_file(hash_path, std::ios::binary); + if (hash_file.is_open()) { - hashFile.put((dataHash >> 24) & 0xFF); - hashFile.put((dataHash >> 16) & 0xFF); - hashFile.put((dataHash >> 8) & 0xFF); - hashFile.put(dataHash & 0xFF); - hashFile.close(); + hash_file.put((data_hash >> 24) & 0xFF); + hash_file.put((data_hash >> 16) & 0xFF); + hash_file.put((data_hash >> 8) & 0xFF); + hash_file.put(data_hash & 0xFF); + hash_file.close(); } } /// @brief Creates the test environment with default data, which is needed in most test cases. -void prepare_environment() +void PrepareEnvironment() { // Prepare the test environment. - mkdir(data_dir.c_str(), 0777); + mkdir(kDataDir.c_str(), 0777); - const std::string default_json_path(default_prefix + ".json"); - const std::string default_hash_path(default_prefix + ".hash"); - const std::string kvs_json_path(kvs_prefix + ".json"); - const std::string kvs_hash_path(kvs_prefix + ".hash"); + const std::string default_json_path(kDefaultPrefix + ".json"); + const std::string default_hash_path(kDefaultPrefix + ".hash"); + const std::string kvs_json_path(kKvsPrefix + ".json"); + const std::string kvs_hash_path(kKvsPrefix + ".hash"); - store(default_json_path, default_hash_path, default_json); - store(kvs_json_path, kvs_hash_path, kvs_json); + Store(default_json_path, default_hash_path, kDefaultJson); + Store(kvs_json_path, kvs_hash_path, kKvsJson); } -void cleanup_environment() +void CleanupEnvironment() { - cleanup_environment(data_dir); + CleanupEnvironment(kDataDir); } -void cleanup_environment(const std::string& dir) +void CleanupEnvironment(const std::string& dir) { // Cleanup the test environment. if (std::filesystem::exists(dir)) diff --git a/score/kvs/kvs_general_test.h b/score/kvs/kvs_general_test.h index b2cb7a827..58ad627e7 100644 --- a/score/kvs/kvs_general_test.h +++ b/score/kvs/kvs_general_test.h @@ -37,75 +37,75 @@ #include "score/kvs/internal/kvs_helper.h" using namespace score::kvs; -uint32_t adler32(const std::string& data); -void prepare_environment(); -void cleanup_environment(); -void cleanup_environment(const std::string& dir); -void store(const std::string& path, const std::string& hashPath, const std::string& data); - -inline void prepare_kvs(const std::string& dir, - const std::string& prefix, - const std::size_t instanceId, - const std::size_t snapshotId) +uint32_t Adler32(const std::string& data); +void PrepareEnvironment(); +void CleanupEnvironment(); +void CleanupEnvironment(const std::string& dir); +void Store(const std::string& file_path, const std::string& hash_path, const std::string& data); + +inline void PrepareKvs(const std::string& dir, + const std::string& prefix, + const std::size_t instance_id, + const std::size_t snapshot_id) { // Do nothing, end of recursion. } template -inline void prepare_kvs(const std::string& dir, - const std::string& prefix, - const std::size_t instanceId, - const std::size_t snapshotId, - const std::string& snapshotData, - TSnapshots&&... snapshots) +inline void PrepareKvs(const std::string& dir, + const std::string& prefix, + const std::size_t instance_id, + const std::size_t snapshot_id, + const std::string& snapshot_data, + TSnapshots&&... snapshots) { - const std::string path{dir + "/" + prefix + std::to_string(instanceId) + "_" + std::to_string(snapshotId)}; - const std::string jsonPath(path + ".json"); - const std::string hashPath(path + ".hash"); + const std::string path{dir + "/" + prefix + std::to_string(instance_id) + "_" + std::to_string(snapshot_id)}; + const std::string json_path(path + ".json"); + const std::string hash_path(path + ".hash"); - store(jsonPath, hashPath, snapshotData); + Store(json_path, hash_path, snapshot_data); - prepare_kvs(dir, prefix, instanceId, (snapshotId + 1ul), std::forward(snapshots)...); + PrepareKvs(dir, prefix, instance_id, (snapshot_id + 1ul), std::forward(snapshots)...); } template -inline void prepare_environment(const std::string& dir, - const std::string& prefix, - const std::size_t instanceId, - const std::string& defaultData, - TSnapshots&&... snapshots) +inline void PrepareEnvironment(const std::string& dir, + const std::string& prefix, + const std::size_t instance_id, + const std::string& default_data, + TSnapshots&&... snapshots) { mkdir(dir.c_str(), 0777); - const std::string path{dir + "/" + prefix + std::to_string(instanceId)}; - const std::string defaultJsonPath(path + "_default.json"); - const std::string defaultHashPath(path + "_default.hash"); + const std::string path{dir + "/" + prefix + std::to_string(instance_id)}; + const std::string default_json_path(path + "_default.json"); + const std::string default_hash_path(path + "_default.hash"); - store(defaultJsonPath, defaultHashPath, defaultData); + Store(default_json_path, default_hash_path, default_data); - prepare_kvs(dir, prefix, instanceId, 0ul, std::forward(snapshots)...); + PrepareKvs(dir, prefix, instance_id, 0ul, std::forward(snapshots)...); } // Default data used in unit tests. -const std::uint32_t instance = 123; -const InstanceId instance_id{instance}; -const SnapshotId snapshot_id{0ul}; +const std::uint32_t kInstance = 123; +const InstanceId kInstanceId{kInstance}; +const SnapshotId kSnapshotId{0ul}; // score::filesystem::Path could be constructed implicitly from std::string. // For readability, the test code constructs it explicitly from these strings. -const std::string data_dir = "./data_folder/"; -const std::string default_prefix = data_dir + "kvs_" + std::to_string(instance) + "_default"; -const std::string kvs_prefix = data_dir + "kvs_" + std::to_string(instance) + "_0"; -const std::string filename_prefix = data_dir + "kvs_" + std::to_string(instance); +const std::string kDataDir = "./data_folder/"; +const std::string kDefaultPrefix = kDataDir + "kvs_" + std::to_string(kInstance) + "_default"; +const std::string kKvsPrefix = kDataDir + "kvs_" + std::to_string(kInstance) + "_0"; +const std::string kFilenamePrefix = kDataDir + "kvs_" + std::to_string(kInstance); -const std::string default_json = R"({ +const std::string kDefaultJson = R"({ "default": { "t": "i32", "v": 5 } })"; -const std::string kvs_json = R"({ +const std::string kKvsJson = R"({ "kvs": { "t": "i32", "v": 2 diff --git a/score/kvs/kvs_helper_test.cpp b/score/kvs/kvs_helper_test.cpp index 5eb84808a..f7b7ed0ed 100644 --- a/score/kvs/kvs_helper_test.cpp +++ b/score/kvs/kvs_helper_test.cpp @@ -19,8 +19,8 @@ TEST(kvs_calculate_hash_adler32, calculate_hash_adler32) // Parsing test is done automatically by the open tests. std::string test_data = "Hello, World!"; - uint32_t calculated_hash = adler32(test_data); - EXPECT_EQ(calculated_hash, calculate_hash_adler32(test_data)); + uint32_t calculated_hash = Adler32(test_data); + EXPECT_EQ(calculated_hash, CalculateHashAdler32(test_data)); std::array buf{}; std::istringstream stream(test_data); @@ -30,22 +30,22 @@ TEST(kvs_calculate_hash_adler32, calculate_hash_adler32) uint8_t((calculated_hash >> 16) & 0xFF), uint8_t((calculated_hash >> 8) & 0xFF), uint8_t((calculated_hash) & 0xFF)}; - EXPECT_EQ(value, get_hash_bytes(test_data)); + EXPECT_EQ(value, GetHashBytes(test_data)); } TEST(kvs_calculate_hash_adler32, calculate_hash_adler32_large_data) { // Create a test string with more than 5552 characters to check that the hash is calculated correctly. std::string large_data(6000, 'A'); - uint32_t hash = calculate_hash_adler32(large_data); + uint32_t hash = CalculateHashAdler32(large_data); - EXPECT_EQ(adler32(large_data), hash); + EXPECT_EQ(Adler32(large_data), hash); } TEST(kvs_check_hash, check_hash_valid) { std::string test_data = "Hello, World!"; - uint32_t hash = adler32(test_data); + uint32_t hash = Adler32(test_data); std::array hash_bytes = {uint8_t((hash >> 24) & 0xFF), uint8_t((hash >> 16) & 0xFF), uint8_t((hash >> 8) & 0xFF), @@ -53,13 +53,13 @@ TEST(kvs_check_hash, check_hash_valid) std::string hash_string(reinterpret_cast(hash_bytes.data()), hash_bytes.size()); std::istringstream hash_stream(hash_string); - EXPECT_TRUE(check_hash(test_data, hash_stream)); + EXPECT_TRUE(CheckHash(test_data, hash_stream)); } TEST(kvs_check_hash, check_hash_invalid) { std::string test_data = "Hello, World!"; - uint32_t hash = adler32(test_data); + uint32_t hash = Adler32(test_data); std::array hash_bytes = {uint8_t((hash >> 24) & 0xFF), uint8_t((hash >> 16) & 0xFF), uint8_t((hash >> 8) & 0xFF), @@ -69,7 +69,7 @@ TEST(kvs_check_hash, check_hash_invalid) std::string test_data_invalid = "Hello, invalid World!"; - EXPECT_FALSE(check_hash(test_data_invalid, hash_stream)); + EXPECT_FALSE(CheckHash(test_data_invalid, hash_stream)); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_bool) @@ -78,9 +78,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_bool) obj.emplace("t", score::json::Any(std::string("bool"))); obj.emplace("v", score::json::Any(true)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::Boolean); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kBoolean); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_i32) @@ -89,9 +89,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_i32) obj.emplace("t", score::json::Any(std::string("i32"))); obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::i32); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kI32); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_u32) @@ -100,9 +100,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_u32) obj.emplace("t", score::json::Any(std::string("u32"))); obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::u32); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kU32); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_i64) @@ -111,9 +111,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_i64) obj.emplace("t", score::json::Any(std::string("i64"))); obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::i64); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kI64); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_u64) @@ -122,9 +122,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_u64) obj.emplace("t", score::json::Any(std::string("u64"))); obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::u64); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kU64); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_f64) @@ -133,9 +133,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_f64) obj.emplace("t", score::json::Any(std::string("f64"))); obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::f64); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kF64); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_string) @@ -144,9 +144,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_string) obj.emplace("t", score::json::Any(std::string("str"))); obj.emplace("v", score::json::Any(std::string("test"))); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::String); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kString); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_null) @@ -155,9 +155,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_null) obj.emplace("t", score::json::Any(std::string("null"))); obj.emplace("v", score::json::Any(score::json::Null())); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::Null); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kNull); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_array) @@ -182,9 +182,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_array) obj.emplace("t", score::json::Any(std::string("arr"))); obj.emplace("v", score::json::Any(std::move(list))); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::Array); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kArray); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_object) @@ -206,9 +206,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_object) obj.emplace("v", score::json::Any(std::move(combined_obj))); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); ASSERT_TRUE(result); - EXPECT_EQ(result.value().getType(), KvsValue::Type::Object); + EXPECT_EQ(result.value().GetType(), KvsValue::Type::kObject); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_format_invalid) @@ -217,25 +217,25 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_format_invalid) obj_type.emplace("invalid", score::json::Any(std::string("bool"))); obj_type.emplace("v", score::json::Any(true)); score::json::Any any_obj_type(std::move(obj_type)); - auto result = any_to_kvsvalue(any_obj_type); + auto result = AnyToKvsValue(any_obj_type); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); score::json::Object obj_value; obj_value.emplace("t", score::json::Any(std::string("bool"))); obj_value.emplace("invalid", score::json::Any(true)); score::json::Any any_obj_value(std::move(obj_value)); - result = any_to_kvsvalue(any_obj_value); + result = AnyToKvsValue(any_obj_value); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_no_object) { score::json::Any any_bool(true); - auto result = any_to_kvsvalue(any_bool); + auto result = AnyToKvsValue(any_bool); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_type_no_string) @@ -245,9 +245,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_type_no_string) obj.emplace("t", score::json::Any(42.0)); obj.emplace("v", score::json::Any(true)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_type_invalid) @@ -256,9 +256,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_type_invalid) obj.emplace("t", "invalid"); obj.emplace("v", score::json::Any(true)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_no_string_type) @@ -268,9 +268,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_no_string_type) obj.emplace("t", score::json::Any(42.0)); obj.emplace("v", score::json::Any(true)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_i32) @@ -280,9 +280,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_i32) // Invalid value for I32. obj.emplace("v", score::json::Any("invalid")); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_u32) @@ -292,9 +292,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_u32) // Invalid value for U32. obj.emplace("v", score::json::Any("invalid")); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_i64) @@ -304,9 +304,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_i64) // Invalid value for I64. obj.emplace("v", score::json::Any("invalid")); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_u64) @@ -316,9 +316,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_u64) // Invalid value for U64. obj.emplace("v", score::json::Any("invalid")); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_f64) @@ -328,9 +328,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_f64) // Invalid value for F64. obj.emplace("v", score::json::Any("invalid")); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_boolean) @@ -340,9 +340,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_boolean) // Invalid value for Boolean. obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_string) @@ -352,9 +352,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_string) // Invalid value for String. obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_null) @@ -364,9 +364,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_null) // Invalid value for Null. obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_array) @@ -376,9 +376,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_array) // Invalid value for Array. obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_object) @@ -388,9 +388,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_invalid_object) // Invalid value for Object. obj.emplace("v", score::json::Any(42.0)); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_array_with_invalid_element) @@ -411,9 +411,9 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_array_with_invalid_element) obj.emplace("t", score::json::Any(std::string("arr"))); obj.emplace("v", score::json::Any(std::move(list))); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_object_with_invalid_value) @@ -435,15 +435,15 @@ TEST(kvs_any_to_kvsvalue, any_to_kvsvalue_object_with_invalid_value) obj.emplace("v", score::json::Any(std::move(value_obj))); score::json::Any any_obj(std::move(obj)); - auto result = any_to_kvsvalue(any_obj); + auto result = AnyToKvsValue(any_obj); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); } TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_null) { KvsValue null_val(nullptr); - auto result = kvsvalue_to_any(null_val); + auto result = KvsValueToAny(null_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "null"); @@ -453,7 +453,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_null) TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_boolean) { KvsValue bool_val(true); - auto result = kvsvalue_to_any(bool_val); + auto result = KvsValueToAny(bool_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "bool"); @@ -463,7 +463,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_boolean) TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_i32) { KvsValue i32_val(static_cast(42)); - auto result = kvsvalue_to_any(i32_val); + auto result = KvsValueToAny(i32_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "i32"); @@ -473,7 +473,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_i32) TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_u32) { KvsValue u32_val(static_cast(42)); - auto result = kvsvalue_to_any(u32_val); + auto result = KvsValueToAny(u32_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "u32"); @@ -483,7 +483,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_u32) TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_i64) { KvsValue i64_val(static_cast(42)); - auto result = kvsvalue_to_any(i64_val); + auto result = KvsValueToAny(i64_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "i64"); @@ -493,7 +493,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_i64) TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_u64) { KvsValue u64_val(static_cast(42)); - auto result = kvsvalue_to_any(u64_val); + auto result = KvsValueToAny(u64_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "u64"); @@ -503,7 +503,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_u64) TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_f64) { KvsValue f64_val(42.0); - auto result = kvsvalue_to_any(f64_val); + auto result = KvsValueToAny(f64_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "f64"); @@ -514,7 +514,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_string) { std::string str = "test"; KvsValue string_val(str); - auto result = kvsvalue_to_any(string_val); + auto result = KvsValueToAny(string_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "str"); @@ -528,7 +528,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_array) array.push_back(KvsValue(1.1)); array.push_back(KvsValue(std::string("test"))); KvsValue array_val(array); - auto result = kvsvalue_to_any(array_val); + auto result = KvsValueToAny(array_val); ASSERT_TRUE(result); const auto& obj = result.value().As().value().get(); EXPECT_EQ(obj.at("t").As().value().get(), "arr"); @@ -557,7 +557,7 @@ TEST(kvs_kvsvalue_to_any, kvsvalue_to_any_object) obj.emplace_back("count", KvsValue(42.0)); KvsValue obj_val(obj); - auto result = kvsvalue_to_any(obj_val); + auto result = KvsValueToAny(obj_val); ASSERT_TRUE(result); const auto& outer_obj = result.value().As().value().get(); diff --git a/score/kvs/kvs_test.cpp b/score/kvs/kvs_test.cpp index fb63bf6b7..2d3217762 100644 --- a/score/kvs/kvs_test.cpp +++ b/score/kvs/kvs_test.cpp @@ -25,24 +25,24 @@ TEST(kvs_constructor, move_constructor) const std::uint32_t instance_b = 5; // Create object A. - auto result_a = Kvs::open(InstanceId(instance_b), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result_a = Kvs::Open(InstanceId(instance_b), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result_a); Kvs kvs_a = std::move(result_a.value()); // Create object B. - auto result_b = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result_b = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result_b); Kvs kvs_b = std::move(result_b.value()); @@ -67,37 +67,37 @@ TEST(kvs_constructor, move_constructor) // Expectations: // - kvs_a now contains data from the former kvs_b (default JSON data). - EXPECT_EQ(kvs_a.filename_prefix_.CStr(), data_dir + "kvs_" + std::to_string(instance)); + EXPECT_EQ(kvs_a.filename_prefix_.CStr(), kDataDir + "kvs_" + std::to_string(kInstance)); EXPECT_TRUE(kvs_a.kvs_.count("test_kvs")); EXPECT_TRUE(kvs_a.default_values_.count("test_default")); const auto& val = kvs_a.kvs_.at("test_kvs"); - EXPECT_EQ(val.getType(), KvsValue::Type::f64); - EXPECT_EQ(std::get(val.getValue()), 42.0); + EXPECT_EQ(val.GetType(), KvsValue::Type::kF64); + EXPECT_EQ(std::get(val.GetValue()), 42.0); const auto& def = kvs_a.default_values_.at("test_default"); - EXPECT_EQ(def.getType(), KvsValue::Type::Boolean); - EXPECT_EQ(std::get(def.getValue()), true); + EXPECT_EQ(def.GetType(), KvsValue::Type::kBoolean); + EXPECT_EQ(std::get(def.GetValue()), true); EXPECT_TRUE(kvs_b.kvs_.empty()); EXPECT_TRUE(kvs_b.default_values_.empty()); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_TEST, parse_json_data_sucess) { // Success. - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); auto mock_parser = std::make_unique(); @@ -113,25 +113,25 @@ TEST(kvs_TEST, parse_json_data_sucess) kvs->parser_ = std::move(mock_parser); - auto result = kvs->parse_json_data("data_not_used_in_mocking"); + auto result = kvs->ParseJsonData("data_not_used_in_mocking"); EXPECT_TRUE(result); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_TEST, parse_json_data_failure) { - prepare_environment(); + PrepareEnvironment(); // JSON parser failure. - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); auto mock_parser = std::make_unique(); @@ -141,25 +141,25 @@ TEST(kvs_TEST, parse_json_data_failure) kvs->parser_ = std::move(mock_parser); - auto result = kvs->parse_json_data("data_not_used_in_mocking"); + auto result = kvs->ParseJsonData("data_not_used_in_mocking"); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::JsonParserError); + EXPECT_EQ(result.error(), ErrorCode::kJsonParserError); // No object returned failure. mock_parser = std::make_unique(); - score::json::Any JsonParserReturnValue(42.0); + score::json::Any json_parser_return_value(42.0); EXPECT_CALL(*mock_parser, FromBuffer(::testing::_)) - .WillOnce(::testing::Return(score::Result(std::move(JsonParserReturnValue)))); + .WillOnce(::testing::Return(score::Result(std::move(json_parser_return_value)))); kvs->parser_ = std::move(mock_parser); - result = kvs->parse_json_data("data_not_used_in_mocking"); + result = kvs->ParseJsonData("data_not_used_in_mocking"); EXPECT_FALSE(result.has_value()); - EXPECT_EQ(result.error(), ErrorCode::JsonParserError); + EXPECT_EQ(result.error(), ErrorCode::kJsonParserError); - // any_to_kvsvalue error. + // AnyToKvsValue error. mock_parser = std::make_unique(); score::json::Object obj; @@ -174,226 +174,226 @@ TEST(kvs_TEST, parse_json_data_failure) kvs->parser_ = std::move(mock_parser); - result = kvs->parse_json_data("data_not_used_in_mocking"); + result = kvs->ParseJsonData("data_not_used_in_mocking"); EXPECT_FALSE(result.has_value()); - // Error is passed from any_to_kvsvalue. - EXPECT_EQ(result.error(), ErrorCode::InvalidValueType); + // Error is passed from AnyToKvsValue. + EXPECT_EQ(result.error(), ErrorCode::kInvalidValueType); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_open, storage_corrupted_all_kvs_open_modes) { - const OpenNeedDefaults defaultMode{OpenNeedDefaults::Required}; - const InstanceId instanceId{99ul}; - const SnapshotId snapshotId{0ul}; - const std::string defaultData = R"({"default": {"t": "i32","v": 10}})"; - const std::string snapshotData0 = R"({"kvs": {"t": "i32","v": 20}})"; + const KvsDefaults default_mode{KvsDefaults::kRequired}; + const InstanceId instance_id{99ul}; + const SnapshotId snapshot_id{0ul}; + const std::string default_data = R"({"default": {"t": "i32","v": 10}})"; + const std::string snapshot_data_0 = R"({"kvs": {"t": "i32","v": 20}})"; const std::string dir{"./kvs/"}; const std::string prefix{"kvs_"}; // Prepare KVS on disk. // Make sure files have been created. - prepare_environment(dir, prefix, instanceId.id, defaultData, snapshotData0); - ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instanceId.id) + "_0.json")); - ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instanceId.id) + "_0.hash")); + PrepareEnvironment(dir, prefix, instance_id.id, default_data, snapshot_data_0); + ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instance_id.id) + "_0.json")); + ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instance_id.id) + "_0.hash")); // Corrupt JSON file. { - const std::string jsonPath{dir + prefix + std::to_string(instanceId.id) + "_0.json"}; - const std::string corruptedData{"random_data"}; - std::ofstream file(jsonPath); + const std::string json_path{dir + prefix + std::to_string(instance_id.id) + "_0.json"}; + const std::string corrupted_data{"random_data"}; + std::ofstream file(json_path); if (file.is_open()) { - file << corruptedData; + file << corrupted_data; file.close(); } } // Required. { - auto kvs = Kvs::open(instanceId, - snapshotId, - defaultMode, - OpenNeedKvs::Required, + auto kvs = Kvs::Open(instance_id, + snapshot_id, + default_mode, + KvsLoad::kRequired, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_FALSE(kvs); - ASSERT_EQ(kvs.error(), ErrorCode::ValidationFailed); + ASSERT_EQ(kvs.error(), ErrorCode::kValidationFailed); } // Optional. { - auto kvs = Kvs::open(instanceId, - snapshotId, - defaultMode, - OpenNeedKvs::Optional, + auto kvs = Kvs::Open(instance_id, + snapshot_id, + default_mode, + KvsLoad::kOptional, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_FALSE(kvs); - ASSERT_EQ(kvs.error(), ErrorCode::ValidationFailed); + ASSERT_EQ(kvs.error(), ErrorCode::kValidationFailed); } // Ignored. { - auto kvs = Kvs::open(instanceId, - snapshotId, - defaultMode, - OpenNeedKvs::Ignored, + auto kvs = Kvs::Open(instance_id, + snapshot_id, + default_mode, + KvsLoad::kIgnored, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); // Successfully opened without loading. ASSERT_TRUE(kvs); // `kvs` should be not present. - ASSERT_FALSE(kvs->get_value("kvs")); + ASSERT_FALSE(kvs->GetValue("kvs")); // No keys available. - auto allKeys = kvs->get_all_keys(); - ASSERT_TRUE(allKeys); - ASSERT_EQ(allKeys->size(), 0ul); + auto all_keys = kvs->GetAllKeys(); + ASSERT_TRUE(all_keys); + ASSERT_EQ(all_keys->size(), 0ul); } - cleanup_environment(dir); + CleanupEnvironment(dir); } TEST(kvs_open, hash_missing_all_kvs_open_modes) { - const OpenNeedDefaults defaultMode{OpenNeedDefaults::Required}; - const InstanceId instanceId{99ul}; - const SnapshotId snapshotId{0ul}; - const std::string defaultData = R"({"default": {"t": "i32","v": 10}})"; - const std::string snapshotData0 = R"({"kvs": {"t": "i32","v": 20}})"; + const KvsDefaults default_mode{KvsDefaults::kRequired}; + const InstanceId instance_id{99ul}; + const SnapshotId snapshot_id{0ul}; + const std::string default_data = R"({"default": {"t": "i32","v": 10}})"; + const std::string snapshot_data_0 = R"({"kvs": {"t": "i32","v": 20}})"; const std::string dir{"./kvs/"}; const std::string prefix{"kvs_"}; // Prepare KVS on disk. // Make sure files have been created. - prepare_environment(dir, prefix, instanceId.id, defaultData, snapshotData0); - ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instanceId.id) + "_0.json")); - ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instanceId.id) + "_0.hash")); + PrepareEnvironment(dir, prefix, instance_id.id, default_data, snapshot_data_0); + ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instance_id.id) + "_0.json")); + ASSERT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instance_id.id) + "_0.hash")); // Remove hash file. - ASSERT_TRUE(std::filesystem::remove(dir + prefix + std::to_string(instanceId.id) + "_0.hash")); + ASSERT_TRUE(std::filesystem::remove(dir + prefix + std::to_string(instance_id.id) + "_0.hash")); // Required. { - auto kvs = Kvs::open(instanceId, - snapshotId, - defaultMode, - OpenNeedKvs::Required, + auto kvs = Kvs::Open(instance_id, + snapshot_id, + default_mode, + KvsLoad::kRequired, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_FALSE(kvs); - ASSERT_EQ(kvs.error(), ErrorCode::KvsHashFileReadError); + ASSERT_EQ(kvs.error(), ErrorCode::kKvsHashFileReadError); } // Optional. { - auto kvs = Kvs::open(instanceId, - snapshotId, - defaultMode, - OpenNeedKvs::Optional, + auto kvs = Kvs::Open(instance_id, + snapshot_id, + default_mode, + KvsLoad::kOptional, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_FALSE(kvs); - ASSERT_EQ(kvs.error(), ErrorCode::KvsHashFileReadError); + ASSERT_EQ(kvs.error(), ErrorCode::kKvsHashFileReadError); } // Ignored. { - auto kvs = Kvs::open(instanceId, - snapshotId, - defaultMode, - OpenNeedKvs::Ignored, + auto kvs = Kvs::Open(instance_id, + snapshot_id, + default_mode, + KvsLoad::kIgnored, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); // Successfully opened without loading. ASSERT_TRUE(kvs); // `kvs` should be not present. - ASSERT_FALSE(kvs->get_value("kvs")); + ASSERT_FALSE(kvs->GetValue("kvs")); // No keys available. - auto allKeys = kvs->get_all_keys(); - ASSERT_TRUE(allKeys); - ASSERT_EQ(allKeys->size(), 0ul); + auto all_keys = kvs->GetAllKeys(); + ASSERT_TRUE(all_keys); + ASSERT_EQ(all_keys->size(), 0ul); } - cleanup_environment(dir); + CleanupEnvironment(dir); } TEST(kvs_open, selected_snapshot) { - const InstanceId instanceId{99ul}; - const std::string defaultData = R"({"default": {"t": "i32","v": 10}})"; - const std::string snapshotData0 = R"({"kvs": {"t": "i32","v": 20}})"; - const std::string snapshotData1 = R"({"kvs": {"t": "i32","v": 30}})"; + const InstanceId instance_id{99ul}; + const std::string default_data = R"({"default": {"t": "i32","v": 10}})"; + const std::string snapshot_data_0 = R"({"kvs": {"t": "i32","v": 20}})"; + const std::string snapshot_data_1 = R"({"kvs": {"t": "i32","v": 30}})"; const std::string dir{"./kvs/"}; const std::string prefix{"kvs_"}; // Prepare KVS on disk with two snapshots. // Make sure files have been created. - prepare_environment(dir, prefix, instanceId.id, defaultData, snapshotData0, snapshotData1); - EXPECT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instanceId.id) + "_0.json")); - EXPECT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instanceId.id) + "_1.json")); + PrepareEnvironment(dir, prefix, instance_id.id, default_data, snapshot_data_0, snapshot_data_1); + EXPECT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instance_id.id) + "_0.json")); + EXPECT_TRUE(std::filesystem::exists(dir + prefix + std::to_string(instance_id.id) + "_1.json")); // First instance, load snapshot 0. { - auto kvs = Kvs::open(instanceId, + auto kvs = Kvs::Open(instance_id, SnapshotId{0ul}, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, + KvsDefaults::kRequired, + KvsLoad::kRequired, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - auto value = kvs->get_value("kvs"); + auto value = kvs->GetValue("kvs"); ASSERT_TRUE(value); - EXPECT_EQ(value.value().getType(), KvsValue::Type::i32); - EXPECT_EQ(std::get(value.value().getValue()), 20u); + EXPECT_EQ(value.value().GetType(), KvsValue::Type::kI32); + EXPECT_EQ(std::get(value.value().GetValue()), 20u); } // Second instance, load snapshot 1. { - auto kvs = Kvs::open(instanceId, + auto kvs = Kvs::Open(instance_id, SnapshotId{1ul}, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, + KvsDefaults::kRequired, + KvsLoad::kRequired, std::string(dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - auto value = kvs->get_value("kvs"); + auto value = kvs->GetValue("kvs"); ASSERT_TRUE(value); - EXPECT_EQ(value.value().getType(), KvsValue::Type::i32); - EXPECT_EQ(std::get(value.value().getValue()), 30u); + EXPECT_EQ(value.value().GetType(), KvsValue::Type::kI32); + EXPECT_EQ(std::get(value.value().GetValue()), 30u); } - cleanup_environment(dir); + CleanupEnvironment(dir); } TEST(kvs_TEST, parse_json_data_rejects_over_length_key) { // comp_req__kvs__key_length: an over-length key found while loading means the file is invalid or corrupted. // Loading must halt with an error and not silently drop data. - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - const std::string valid_key(KVS_MAX_KEY_LENGTH_BYTES, 'a'); - const std::string too_long_key(KVS_MAX_KEY_LENGTH_BYTES + 1U, 'b'); + const std::string valid_key(kMaxKeyLengthBytes, 'a'); + const std::string too_long_key(kMaxKeyLengthBytes + 1U, 'b'); auto mock_parser = std::make_unique(); score::json::Object obj; @@ -414,26 +414,26 @@ TEST(kvs_TEST, parse_json_data_rejects_over_length_key) kvs->parser_ = std::move(mock_parser); - auto result = kvs->parse_json_data("data_not_used_in_mocking"); + auto result = kvs->ParseJsonData("data_not_used_in_mocking"); ASSERT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::InvalidKey); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kInvalidKey); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_TEST, parse_json_data_rejects_empty_key) { // comp_req__kvs__key_length: an empty key found while loading means the file is invalid or corrupted. // Loading must halt with an error. - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); auto mock_parser = std::make_unique(); @@ -455,25 +455,25 @@ TEST(kvs_TEST, parse_json_data_rejects_empty_key) kvs->parser_ = std::move(mock_parser); - auto result = kvs->parse_json_data("data_not_used_in_mocking"); + auto result = kvs->ParseJsonData("data_not_used_in_mocking"); ASSERT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::InvalidKey); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kInvalidKey); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_TEST, parse_json_data_rejects_invalid_characters_key) { // comp_req__kvs__key_naming: a key with characters outside printable ASCII means the file is invalid or corrupted. - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); const std::vector invalid_keys{"\x1f", "\x7f", "tab\tkey", u8"ą", "\x80"}; @@ -498,47 +498,47 @@ TEST(kvs_TEST, parse_json_data_rejects_invalid_characters_key) kvs->parser_ = std::move(mock_parser); - auto result = kvs->parse_json_data("data_not_used_in_mocking"); + auto result = kvs->ParseJsonData("data_not_used_in_mocking"); ASSERT_FALSE(result) << "key: " << invalid_key; - EXPECT_EQ(static_cast(*result.error()), ErrorCode::InvalidKey) << "key: " << invalid_key; + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kInvalidKey) << "key: " << invalid_key; } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_open_json, open_json_success) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - auto result = kvs->open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Required); + auto result = kvs->OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kRequired); EXPECT_TRUE(result); - result = kvs->open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Optional); + result = kvs->OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kOptional); EXPECT_TRUE(result); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_open_json, open_json_json_invalid) { - prepare_environment(); - // JSON data invalid (parse_json_data() failure). + PrepareEnvironment(); + // JSON data invalid (ParseJsonData() failure). std::string invalid_json = "{ invalid json }"; - std::ofstream invalid_json_file(kvs_prefix + ".json"); + std::ofstream invalid_json_file(kKvsPrefix + ".json"); invalid_json_file << invalid_json; invalid_json_file.close(); // Still valid hash. - uint32_t kvs_hash = adler32(invalid_json); - std::ofstream kvs_hash_file(kvs_prefix + ".hash", std::ios::binary); + uint32_t kvs_hash = Adler32(invalid_json); + std::ofstream kvs_hash_file(kKvsPrefix + ".hash", std::ios::binary); kvs_hash_file.put((kvs_hash >> 24) & 0xFF); kvs_hash_file.put((kvs_hash >> 16) & 0xFF); kvs_hash_file.put((kvs_hash >> 8) & 0xFF); @@ -555,25 +555,25 @@ TEST(kvs_open_json, open_json_json_invalid) }); kvs.parser_ = std::move(mock_parser); - auto result = kvs.open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Required); + auto result = kvs.OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kRequired); ASSERT_FALSE(result); - // Error code passed by parse_json_data(). - EXPECT_EQ(static_cast(*result.error()), ErrorCode::JsonParserError); + // Error code passed by ParseJsonData(). + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kJsonParserError); // JSON not existing. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - result = kvs.open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Required); + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + result = kvs.OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kRequired); ASSERT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::KvsFileReadError); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kKvsFileReadError); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_open_json, open_json_hash_invalid) { - prepare_environment(); + PrepareEnvironment(); // Hash corrupted. - std::fstream corrupt_default_hash_file(kvs_prefix + ".hash", std::ios::in | std::ios::out | std::ios::binary); + std::fstream corrupt_default_hash_file(kKvsPrefix + ".hash", std::ios::in | std::ios::out | std::ios::binary); corrupt_default_hash_file.seekp(0); corrupt_default_hash_file.put(0xFF); corrupt_default_hash_file.close(); @@ -581,88 +581,88 @@ TEST(kvs_open_json, open_json_hash_invalid) // Create Kvs instance without any data (this constructor is normally private). Kvs kvs = Kvs(); - auto result = kvs.open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Optional); + auto result = kvs.OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kOptional); ASSERT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::ValidationFailed); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kValidationFailed); // Hash not existing. - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - result = kvs.open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Optional); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + result = kvs.OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kOptional); ASSERT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::KvsHashFileReadError); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kKvsHashFileReadError); // JSON not existing. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - result = kvs.open_json(score::filesystem::Path(kvs_prefix), OpenJsonNeedFile::Required); + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + result = kvs.OpenJson(score::filesystem::Path(kKvsPrefix), OpenJsonNeedFile::kRequired); ASSERT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::KvsFileReadError); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kKvsFileReadError); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_reset, reset_success) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. EXPECT_FALSE(result.value().kvs_.empty()); // Reset KVS. - auto reset_result = result.value().reset(); + auto reset_result = result.value().Reset(); EXPECT_TRUE(reset_result); EXPECT_TRUE(result.value().kvs_.empty()); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_reset, reset_failure) { - prepare_environment(); + PrepareEnvironment(); // Mutex locked. - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto reset_result = result.value().reset(); + auto reset_result = result.value().Reset(); EXPECT_FALSE(reset_result); - EXPECT_EQ(static_cast(*reset_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*reset_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_all_keys, get_all_keys_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. EXPECT_FALSE(result.value().kvs_.empty()); // Check if all keys are returned. - auto get_all_keys_result = result.value().get_all_keys(); + auto get_all_keys_result = result.value().GetAllKeys(); ASSERT_TRUE(get_all_keys_result); EXPECT_FALSE(get_all_keys_result.value().empty()); @@ -671,105 +671,105 @@ TEST(kvs_get_all_keys, get_all_keys_success) // Check if empty keys are returned. result.value().kvs_.clear(); - get_all_keys_result = result.value().get_all_keys(); + get_all_keys_result = result.value().GetAllKeys(); EXPECT_TRUE(get_all_keys_result.value().empty()); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_all_keys, get_all_keys_failure) { - prepare_environment(); + PrepareEnvironment(); // Mutex locked. - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto get_all_keys_result = result.value().get_all_keys(); + auto get_all_keys_result = result.value().GetAllKeys(); EXPECT_FALSE(get_all_keys_result); - EXPECT_EQ(static_cast(*get_all_keys_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*get_all_keys_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_key_exists, key_exists_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. EXPECT_FALSE(result.value().kvs_.empty()); // Check if key exists. - auto exists_result = result.value().key_exists("kvs"); + auto exists_result = result.value().KeyExists("kvs"); EXPECT_TRUE(exists_result); EXPECT_TRUE(exists_result.value()); // Check if non-existing key returns false. - exists_result = result.value().key_exists("non_existing_key"); + exists_result = result.value().KeyExists("non_existing_key"); EXPECT_TRUE(exists_result); EXPECT_FALSE(exists_result.value()); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_key_exists, key_exists_failure) { - prepare_environment(); + PrepareEnvironment(); // Mutex locked. - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto exists_result = result.value().key_exists("kvs"); + auto exists_result = result.value().KeyExists("kvs"); EXPECT_FALSE(exists_result); - EXPECT_EQ(static_cast(*exists_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*exists_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_value, get_value_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. EXPECT_FALSE(result.value().kvs_.empty()); // Check if value is returned. - auto get_value_result = result.value().get_value("kvs"); + auto get_value_result = result.value().GetValue("kvs"); ASSERT_TRUE(get_value_result); - EXPECT_EQ(get_value_result.value().getType(), KvsValue::Type::i32); - EXPECT_EQ(std::get(get_value_result.value().getValue()), 2); + EXPECT_EQ(get_value_result.value().GetType(), KvsValue::Type::kI32); + EXPECT_EQ(std::get(get_value_result.value().GetValue()), 2); // Check if default value is returned when no written key exists. result.value().kvs_.clear(); @@ -777,59 +777,59 @@ TEST(kvs_get_value, get_value_success) ASSERT_TRUE(result.value().kvs_.empty()); int32_t default_value(42); result.value().default_values_.insert_or_assign("kvs", KvsValue(default_value)); - get_value_result = result.value().get_value("kvs"); + get_value_result = result.value().GetValue("kvs"); ASSERT_FALSE(get_value_result); - EXPECT_EQ(get_value_result.error(), ErrorCode::KeyNotFound); + EXPECT_EQ(get_value_result.error(), ErrorCode::kKeyNotFound); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_value, get_value_failure) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check if non-existing key returns error. - auto get_value_result = result.value().get_value("non_existing_key"); + auto get_value_result = result.value().GetValue("non_existing_key"); EXPECT_FALSE(get_value_result); - EXPECT_EQ(get_value_result.error(), ErrorCode::KeyNotFound); + EXPECT_EQ(get_value_result.error(), ErrorCode::kKeyNotFound); // Mutex locked. - result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - get_value_result = result.value().get_value("kvs"); + get_value_result = result.value().GetValue("kvs"); EXPECT_FALSE(get_value_result); - EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_default_value, get_default_value_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. @@ -837,46 +837,46 @@ TEST(kvs_get_default_value, get_default_value_success) result.value().default_values_.insert_or_assign("kvs", KvsValue(default_value)); // Check if default value is returned. - auto get_def_value_result = result.value().get_default_value("kvs"); + auto get_def_value_result = result.value().GetDefaultValue("kvs"); ASSERT_TRUE(get_def_value_result); - EXPECT_EQ(get_def_value_result.value().getType(), KvsValue::Type::i32); - EXPECT_EQ(std::get(get_def_value_result.value().getValue()), 42); + EXPECT_EQ(get_def_value_result.value().GetType(), KvsValue::Type::kI32); + EXPECT_EQ(std::get(get_def_value_result.value().GetValue()), 42); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_default_value, get_default_value_failure) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check if non-existing key returns error. - auto get_def_value_result = result.value().get_default_value("non_existing_key"); + auto get_def_value_result = result.value().GetDefaultValue("non_existing_key"); EXPECT_FALSE(get_def_value_result); - EXPECT_EQ(get_def_value_result.error(), ErrorCode::KeyNotFound); + EXPECT_EQ(get_def_value_result.error(), ErrorCode::kKeyNotFound); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_reset_key, reset_key_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. ASSERT_TRUE(result.value().kvs_.count("kvs")); @@ -884,80 +884,80 @@ TEST(kvs_reset_key, reset_key_success) // Create default value for "kvs" key. result.value().default_values_.insert_or_assign("kvs", KvsValue(42.0)); // Reset a key. - auto reset_key_result = result.value().reset_key("kvs"); + auto reset_key_result = result.value().ResetKey("kvs"); EXPECT_TRUE(reset_key_result); EXPECT_FALSE(result.value().kvs_.count("kvs")); EXPECT_TRUE(result.value().default_values_.count("kvs")); // Reset a non written key which has default value. result.value().default_values_.insert_or_assign("default", KvsValue(42.0)); - reset_key_result = result.value().reset_key("default"); + reset_key_result = result.value().ResetKey("default"); EXPECT_TRUE(reset_key_result); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_reset_key, reset_key_failure) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Reset a non-existing key. - auto reset_key_result = result.value().reset_key("non_existing_key"); + auto reset_key_result = result.value().ResetKey("non_existing_key"); EXPECT_FALSE(reset_key_result); - EXPECT_EQ(reset_key_result.error(), ErrorCode::KeyDefaultNotFound); + EXPECT_EQ(reset_key_result.error(), ErrorCode::kKeyDefaultNotFound); // Reset a key without default value. - result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Clear default values to ensure no default value exists for "kvs". result.value().default_values_.clear(); - reset_key_result = result.value().reset_key("kvs"); + reset_key_result = result.value().ResetKey("kvs"); EXPECT_FALSE(reset_key_result); - EXPECT_EQ(reset_key_result.error(), ErrorCode::KeyDefaultNotFound); + EXPECT_EQ(reset_key_result.error(), ErrorCode::kKeyDefaultNotFound); // Mutex locked. - result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - reset_key_result = result.value().reset_key("kvs"); + reset_key_result = result.value().ResetKey("kvs"); EXPECT_FALSE(reset_key_result); - EXPECT_EQ(static_cast(*reset_key_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*reset_key_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_is_value_default, is_value_default) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); auto kvs{std::move(result.value())}; @@ -967,136 +967,136 @@ TEST(kvs_is_value_default, is_value_default) // Check non-default value. { - auto result{kvs.is_value_default("not-default")}; + auto result{kvs.IsValueDefault("not-default")}; ASSERT_TRUE(result); ASSERT_FALSE(result.value()); } // Check default value. { - auto result{kvs.is_value_default("default")}; + auto result{kvs.IsValueDefault("default")}; ASSERT_TRUE(result); ASSERT_TRUE(result.value()); } // Check key not found. { - auto result{kvs.is_value_default("non_existing_key")}; + auto result{kvs.IsValueDefault("non_existing_key")}; ASSERT_FALSE(result); - ASSERT_EQ(result.error(), ErrorCode::KeyNotFound); + ASSERT_EQ(result.error(), ErrorCode::kKeyNotFound); } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_is_value_default, is_value_default_failure) { - prepare_environment(); + PrepareEnvironment(); - /* Mutex locked */ - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + // Mutex locked. + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto default_result = result.value().is_value_default("default"); + auto default_result = result.value().IsValueDefault("default"); EXPECT_FALSE(default_result); - EXPECT_EQ(static_cast(*default_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*default_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_set_value, set_value_success) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Set a new value. - auto set_value_result = result.value().set_value("new_key", KvsValue(3.14)); + auto set_value_result = result.value().SetValue("new_key", KvsValue(3.14)); EXPECT_TRUE(set_value_result); EXPECT_TRUE(result.value().kvs_.count("new_key")); - EXPECT_EQ(result.value().kvs_.at("new_key").getType(), KvsValue::Type::f64); - EXPECT_DOUBLE_EQ(std::get(result.value().kvs_.at("new_key").getValue()), 3.14); + EXPECT_EQ(result.value().kvs_.at("new_key").GetType(), KvsValue::Type::kF64); + EXPECT_DOUBLE_EQ(std::get(result.value().kvs_.at("new_key").GetValue()), 3.14); // Set a value with an existing key. - set_value_result = result.value().set_value("kvs", KvsValue(2.718)); + set_value_result = result.value().SetValue("kvs", KvsValue(2.718)); EXPECT_TRUE(set_value_result); - EXPECT_EQ(result.value().kvs_.at("kvs").getType(), KvsValue::Type::f64); - EXPECT_DOUBLE_EQ(std::get(result.value().kvs_.at("kvs").getValue()), 2.718); + EXPECT_EQ(result.value().kvs_.at("kvs").GetType(), KvsValue::Type::kF64); + EXPECT_DOUBLE_EQ(std::get(result.value().kvs_.at("kvs").GetValue()), 2.718); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_set_value, set_value_key_too_long) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); - // A key of exactly KVS_MAX_KEY_LENGTH_BYTES bytes is accepted (inclusive limit). - std::string boundary_key(KVS_MAX_KEY_LENGTH_BYTES, 'k'); - auto boundary_result = result.value().set_value(boundary_key, KvsValue(3.14)); + // A key of exactly kMaxKeyLengthBytes bytes is accepted (inclusive limit). + std::string boundary_key(kMaxKeyLengthBytes, 'k'); + auto boundary_result = result.value().SetValue(boundary_key, KvsValue(3.14)); EXPECT_TRUE(boundary_result); - // A key of KVS_MAX_KEY_LENGTH_BYTES + 1 bytes is rejected with InvalidKey. - std::string too_long_key(KVS_MAX_KEY_LENGTH_BYTES + 1U, 'k'); - auto set_value_result = result.value().set_value(too_long_key, KvsValue(3.14)); + // A key of kMaxKeyLengthBytes + 1 bytes is rejected with kInvalidKey. + std::string too_long_key(kMaxKeyLengthBytes + 1U, 'k'); + auto set_value_result = result.value().SetValue(too_long_key, KvsValue(3.14)); EXPECT_FALSE(set_value_result); - EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::InvalidKey); + EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::kInvalidKey); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_value, get_value_failure_key_too_long) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Keys are validated only when set. - // Lookups of keys at and above KVS_MAX_KEY_LENGTH_BYTES are both ordinary lookups of missing keys. - std::string boundary_key(KVS_MAX_KEY_LENGTH_BYTES, 'k'); - auto boundary_result = result.value().get_value(boundary_key); + // Lookups of keys at and above kMaxKeyLengthBytes are both ordinary lookups of missing keys. + std::string boundary_key(kMaxKeyLengthBytes, 'k'); + auto boundary_result = result.value().GetValue(boundary_key); EXPECT_FALSE(boundary_result); - EXPECT_EQ(static_cast(*boundary_result.error()), ErrorCode::KeyNotFound); + EXPECT_EQ(static_cast(*boundary_result.error()), ErrorCode::kKeyNotFound); - std::string too_long_key(KVS_MAX_KEY_LENGTH_BYTES + 1U, 'k'); - auto get_value_result = result.value().get_value(too_long_key); + std::string too_long_key(kMaxKeyLengthBytes + 1U, 'k'); + auto get_value_result = result.value().GetValue(too_long_key); EXPECT_FALSE(get_value_result); - EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::KeyNotFound); + EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::kKeyNotFound); - cleanup_environment(); + CleanupEnvironment(); } namespace { /// @brief Keys with characters outside printable ASCII (0x20 - 0x7E) and a valid length. /// @note comp_req__kvs__key_naming -std::vector invalid_character_keys() +std::vector InvalidCharacterKeys() { return { // Characters just outside the allowed range. @@ -1121,14 +1121,14 @@ std::vector invalid_character_keys() TEST(kvs_set_value, set_value_valid_keys) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // comp_req__kvs__key_naming: any key consisting of printable ASCII characters is accepted. @@ -1153,220 +1153,220 @@ TEST(kvs_set_value, set_value_valid_keys) } for (const auto& key : valid_keys) { - auto set_value_result = result.value().set_value(key, KvsValue(3.14)); + auto set_value_result = result.value().SetValue(key, KvsValue(3.14)); EXPECT_TRUE(set_value_result) << "key: " << key; EXPECT_TRUE(result.value().kvs_.count(key)) << "key: " << key; } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_set_value, set_value_empty_key) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); - // comp_req__kvs__key_length: an empty key is rejected with InvalidKey. + // comp_req__kvs__key_length: an empty key is rejected with kInvalidKey. const auto kvs_size = result.value().kvs_.size(); - auto set_value_result = result.value().set_value("", KvsValue(3.14)); + auto set_value_result = result.value().SetValue("", KvsValue(3.14)); EXPECT_FALSE(set_value_result); - EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::InvalidKey); + EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::kInvalidKey); EXPECT_EQ(result.value().kvs_.size(), kvs_size); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_set_value, set_value_failure_invalid_characters) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); - for (const auto& key : invalid_character_keys()) + for (const auto& key : InvalidCharacterKeys()) { - auto set_value_result = result.value().set_value(key, KvsValue(3.14)); + auto set_value_result = result.value().SetValue(key, KvsValue(3.14)); ASSERT_FALSE(set_value_result) << "key: " << key; - EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::InvalidKey) << "key: " << key; + EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::kInvalidKey) << "key: " << key; EXPECT_FALSE(result.value().kvs_.count(key)) << "key: " << key; } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_value, get_value_failure_empty_key) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Keys are validated only when set, so an empty key is reported as missing. - auto get_value_result = result.value().get_value(""); + auto get_value_result = result.value().GetValue(""); EXPECT_FALSE(get_value_result); - EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::KeyNotFound); + EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::kKeyNotFound); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_value, get_value_failure_invalid_characters) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Keys are validated only when set. // A key with characters outside printable ASCII is reported as missing. - for (const auto& key : invalid_character_keys()) + for (const auto& key : InvalidCharacterKeys()) { - auto get_value_result = result.value().get_value(key); + auto get_value_result = result.value().GetValue(key); ASSERT_FALSE(get_value_result) << "key: " << key; - EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::KeyNotFound) << "key: " << key; + EXPECT_EQ(static_cast(*get_value_result.error()), ErrorCode::kKeyNotFound) << "key: " << key; } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_set_value, set_value_failure) { - prepare_environment(); + PrepareEnvironment(); // Mutex locked. - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto set_value_result = result.value().set_value("new_key", KvsValue(3.0)); + auto set_value_result = result.value().SetValue("new_key", KvsValue(3.0)); EXPECT_FALSE(set_value_result); - EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*set_value_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_remove_key, remove_key_success) { - prepare_environment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + PrepareEnvironment(); + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Check that data exists. EXPECT_TRUE(result.value().kvs_.count("kvs")); // Remove an existing key. - auto remove_key_result = result.value().remove_key("kvs"); + auto remove_key_result = result.value().RemoveKey("kvs"); EXPECT_TRUE(remove_key_result); EXPECT_FALSE(result.value().kvs_.count("kvs")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_remove_key, remove_key_failure) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Remove a non-existing key. - auto remove_key_result = result.value().remove_key("non_existing_key"); + auto remove_key_result = result.value().RemoveKey("non_existing_key"); EXPECT_FALSE(remove_key_result); - EXPECT_EQ(remove_key_result.error(), ErrorCode::KeyNotFound); + EXPECT_EQ(remove_key_result.error(), ErrorCode::kKeyNotFound); // Mutex locked. - result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - remove_key_result = result.value().remove_key("kvs"); + remove_key_result = result.value().RemoveKey("kvs"); EXPECT_FALSE(remove_key_result); - EXPECT_EQ(static_cast(*remove_key_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*remove_key_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_success) { - prepare_environment(); - // Test writing valid JSON data, also checks get_hash_bytes_adler32 and get_hash_bytes. + PrepareEnvironment(); + // Test writing valid JSON data, also checks GetHashBytesAdler32 and GetHashBytes. const char* json_test_data = R"({ "booltest": { "t": "bool", "v": 1 }, })"; - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - kvs->filename_prefix_ = score::filesystem::Path(filename_prefix); - auto result = kvs->write_json_data(json_test_data); + kvs->filename_prefix_ = score::filesystem::Path(kFilenamePrefix); + auto result = kvs->WriteJsonData(json_test_data); EXPECT_TRUE(result); - EXPECT_TRUE(std::filesystem::exists(kvs_prefix + ".json")); - EXPECT_TRUE(std::filesystem::exists(kvs_prefix + ".hash")); + EXPECT_TRUE(std::filesystem::exists(kKvsPrefix + ".json")); + EXPECT_TRUE(std::filesystem::exists(kKvsPrefix + ".hash")); // Check if the content and hash is correct. - std::ifstream in_content(kvs_prefix + ".json", std::ios::binary); + std::ifstream in_content(kKvsPrefix + ".json", std::ios::binary); std::string file_content((std::istreambuf_iterator(in_content)), std::istreambuf_iterator()); in_content.close(); EXPECT_EQ(file_content, json_test_data); - std::ifstream in_hash(kvs_prefix + ".hash", std::ios::binary); + std::ifstream in_hash(kKvsPrefix + ".hash", std::ios::binary); std::string hash_content((std::istreambuf_iterator(in_hash)), std::istreambuf_iterator()); in_hash.close(); - uint32_t hash = adler32(json_test_data); + uint32_t hash = Adler32(json_test_data); std::array hash_bytes = {uint8_t((hash >> 24) & 0xFF), uint8_t((hash >> 16) & 0xFF), uint8_t((hash >> 8) & 0xFF), @@ -1374,23 +1374,23 @@ TEST(kvs_write_json_data, write_json_data_success) std::string expected_hash_string(reinterpret_cast(hash_bytes.data()), hash_bytes.size()); EXPECT_EQ(hash_content, expected_hash_string); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_filesystem_failure) { - prepare_environment(); + PrepareEnvironment(); // Test CreateDirectories fails. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Mock filesystem. @@ -1402,101 +1402,101 @@ TEST(kvs_write_json_data, write_json_data_filesystem_failure) score::Result(score::MakeUnexpected(score::filesystem::ErrorCode::kCouldNotCreateDirectory)))); kvs.value().filesystem_ = std::make_unique(std::move(mock_filesystem)); - auto result = kvs->write_json_data(kvs_json); + auto result = kvs->WriteJsonData(kKvsJson); EXPECT_FALSE(result); - EXPECT_EQ(result.error(), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(result.error(), ErrorCode::kPhysicalStorageFailure); - // Test if path argument is missing parent path (will only occur if semantic errors will be done in flush() ). + // Test if path argument is missing parent path (will only occur if semantic errors will be done in Flush() ). kvs->filename_prefix_ = score::filesystem::Path("no_parent_path"); - result = kvs->write_json_data(kvs_json); + result = kvs->WriteJsonData(kKvsJson); EXPECT_FALSE(result); - EXPECT_EQ(result.error(), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(result.error(), ErrorCode::kPhysicalStorageFailure); - cleanup_environment(); + CleanupEnvironment(); } namespace { using score::filesystem::Perms; /// @brief Expected permissions of KVS JSON and hash files: 0640. -constexpr Perms expected_file_perms{Perms::kReadUser | Perms::kWriteUser | Perms::kReadGroup}; +constexpr Perms kExpectedFilePerms{Perms::kReadUser | Perms::kWriteUser | Perms::kReadGroup}; -/// @brief JSON data different from the data stored by prepare_environment(). -const std::string new_kvs_json = R"({"new_key": {"t": "i32", "v": 1}})"; +/// @brief JSON data different from the data stored by PrepareEnvironment(). +const std::string kNewKvsJson = R"({"new_key": {"t": "i32", "v": 1}})"; -score::filesystem::Filesystem real_filesystem() +score::filesystem::Filesystem RealFilesystem() { return score::filesystem::FilesystemFactory{}.CreateInstance(); } /// @brief Reads permissions of a file as an integer, readable on failure. /// @return The permissions, or kUnknown if the status could not be retrieved. -std::uint32_t file_perms(const score::filesystem::Path& path) +std::uint32_t FilePerms(const score::filesystem::Path& path) { - const auto status = real_filesystem().standard->Status(path); + const auto status = RealFilesystem().standard->Status(path); return static_cast(status.has_value() ? status.value().Permissions() : Perms::kUnknown); } -bool file_exists(const score::filesystem::Path& path) +bool FileExists(const score::filesystem::Path& path) { - const auto exists = real_filesystem().standard->Exists(path); + const auto exists = RealFilesystem().standard->Exists(path); return exists.has_value() && exists.value(); } -std::string file_content(const score::filesystem::Path& path) +std::string FileContent(const score::filesystem::Path& path) { std::ifstream file(path.Native(), std::ios::binary); return std::string(std::istreambuf_iterator(file), std::istreambuf_iterator()); } -Kvs open_test_kvs() +Kvs OpenTestKvs() { - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); EXPECT_TRUE(kvs); - kvs->filename_prefix_ = score::filesystem::Path(filename_prefix); + kvs->filename_prefix_ = score::filesystem::Path(kFilenamePrefix); return std::move(kvs.value()); } } // namespace TEST(kvs_write_json_data, write_json_data_open_failure) { - prepare_environment(); + PrepareEnvironment(); // Test failing to open a temporary file fails the write and keeps the previous files. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - const std::string previous_hash = file_content(hash_path); - auto kvs = open_test_kvs(); + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + const std::string previous_hash = FileContent(hash_path); + auto kvs = OpenTestKvs(); { score::os::MockGuard<::testing::NiceMock> fcntl_mock; - EXPECT_CALL(*fcntl_mock, open(::testing::StrEq(kvs_prefix + ".json.tmp"), ::testing::_, ::testing::_)) + EXPECT_CALL(*fcntl_mock, open(::testing::StrEq(kKvsPrefix + ".json.tmp"), ::testing::_, ::testing::_)) .WillOnce(::testing::Return(score::cpp::make_unexpected(score::os::Error::createFromErrno(EACCES)))); - auto result = kvs.write_json_data(new_kvs_json); + auto result = kvs.WriteJsonData(kNewKvsJson); ASSERT_FALSE(result); - EXPECT_EQ(result.error(), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(result.error(), ErrorCode::kPhysicalStorageFailure); } - EXPECT_EQ(file_content(json_path), kvs_json); - EXPECT_EQ(file_content(hash_path), previous_hash); - EXPECT_FALSE(file_exists(score::filesystem::Path{kvs_prefix + ".json.tmp"})); + EXPECT_EQ(FileContent(json_path), kKvsJson); + EXPECT_EQ(FileContent(hash_path), previous_hash); + EXPECT_FALSE(FileExists(score::filesystem::Path{kKvsPrefix + ".json.tmp"})); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_set_permissions_failure) { - prepare_environment(); + PrepareEnvironment(); // Test setting permissions of a written file fails and keeps the previous files. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - const std::string previous_hash = file_content(hash_path); - auto kvs = open_test_kvs(); + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + const std::string previous_hash = FileContent(hash_path); + auto kvs = OpenTestKvs(); { score::os::MockGuard<::testing::NiceMock> stat_mock; @@ -1505,418 +1505,416 @@ TEST(kvs_write_json_data, write_json_data_set_permissions_failure) score::os::Stat::Mode::kReadUser | score::os::Stat::Mode::kWriteUser | score::os::Stat::Mode::kReadGroup)) .WillOnce(::testing::Return(score::cpp::make_unexpected(score::os::Error::createFromErrno(EPERM)))); - auto result = kvs.write_json_data(new_kvs_json); + auto result = kvs.WriteJsonData(kNewKvsJson); ASSERT_FALSE(result); - EXPECT_EQ(result.error(), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(result.error(), ErrorCode::kPhysicalStorageFailure); } - EXPECT_EQ(file_content(json_path), kvs_json); - EXPECT_EQ(file_content(hash_path), previous_hash); - EXPECT_FALSE(file_exists(score::filesystem::Path{kvs_prefix + ".json.tmp"})); + EXPECT_EQ(FileContent(json_path), kKvsJson); + EXPECT_EQ(FileContent(hash_path), previous_hash); + EXPECT_FALSE(FileExists(score::filesystem::Path{kKvsPrefix + ".json.tmp"})); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_staging_failure_keeps_previous_file) { - prepare_environment(); + PrepareEnvironment(); // Test a temporary file that cannot be removed or created fails the write and keeps the previous files. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - const score::filesystem::Path json_tmp_path{kvs_prefix + ".json.tmp"}; - const std::string previous_hash = file_content(hash_path); - const auto fs{real_filesystem()}; + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + const score::filesystem::Path json_tmp_path{kKvsPrefix + ".json.tmp"}; + const std::string previous_hash = FileContent(hash_path); + const auto fs{RealFilesystem()}; ASSERT_TRUE(fs.standard->CreateDirectory(json_tmp_path)); std::ofstream{json_tmp_path.Native() + "/file"} << "data"; - auto kvs = open_test_kvs(); + auto kvs = OpenTestKvs(); - auto result = kvs.write_json_data(new_kvs_json); + auto result = kvs.WriteJsonData(kNewKvsJson); ASSERT_FALSE(result); - EXPECT_EQ(result.error(), ErrorCode::PhysicalStorageFailure); - EXPECT_EQ(file_content(json_path), kvs_json); - EXPECT_EQ(file_content(hash_path), previous_hash); - EXPECT_FALSE(file_exists(score::filesystem::Path{kvs_prefix + ".hash.tmp"})); + EXPECT_EQ(result.error(), ErrorCode::kPhysicalStorageFailure); + EXPECT_EQ(FileContent(json_path), kKvsJson); + EXPECT_EQ(FileContent(hash_path), previous_hash); + EXPECT_FALSE(FileExists(score::filesystem::Path{kKvsPrefix + ".hash.tmp"})); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_replaces_stale_temp_file) { - prepare_environment(); + PrepareEnvironment(); // Test a temporary file left behind by an interrupted write is replaced. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path json_tmp_path{kvs_prefix + ".json.tmp"}; - const auto fs{real_filesystem()}; + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path json_tmp_path{kKvsPrefix + ".json.tmp"}; + const auto fs{RealFilesystem()}; std::ofstream{json_tmp_path.Native()} << "stale"; constexpr Perms all_perms{Perms::kReadWriteExecUser | Perms::kReadWriteExecGroup | Perms::kReadWriteExecOthers}; ASSERT_TRUE(fs.standard->Permissions(json_tmp_path, all_perms)); - auto kvs = open_test_kvs(); + auto kvs = OpenTestKvs(); - ASSERT_TRUE(kvs.write_json_data(new_kvs_json)); - EXPECT_FALSE(file_exists(json_tmp_path)); - EXPECT_EQ(file_content(json_path), new_kvs_json); - EXPECT_EQ(file_perms(json_path), static_cast(expected_file_perms)); + ASSERT_TRUE(kvs.WriteJsonData(kNewKvsJson)); + EXPECT_FALSE(FileExists(json_tmp_path)); + EXPECT_EQ(FileContent(json_path), kNewKvsJson); + EXPECT_EQ(FilePerms(json_path), static_cast(kExpectedFilePerms)); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_leaves_no_temp_files) { - prepare_environment(); + PrepareEnvironment(); // Test temporary files are renamed to the JSON and hash files. - auto kvs = open_test_kvs(); + auto kvs = OpenTestKvs(); - ASSERT_TRUE(kvs.write_json_data(new_kvs_json)); - EXPECT_EQ(file_content(score::filesystem::Path{kvs_prefix + ".json"}), new_kvs_json); - EXPECT_FALSE(file_exists(score::filesystem::Path{kvs_prefix + ".json.tmp"})); - EXPECT_FALSE(file_exists(score::filesystem::Path{kvs_prefix + ".hash.tmp"})); + ASSERT_TRUE(kvs.WriteJsonData(kNewKvsJson)); + EXPECT_EQ(FileContent(score::filesystem::Path{kKvsPrefix + ".json"}), kNewKvsJson); + EXPECT_FALSE(FileExists(score::filesystem::Path{kKvsPrefix + ".json.tmp"})); + EXPECT_FALSE(FileExists(score::filesystem::Path{kKvsPrefix + ".hash.tmp"})); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_permissions_ignore_umask) { - prepare_environment(); + PrepareEnvironment(); // Test JSON and hash files have 0640 permissions regardless of umask. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - auto kvs = open_test_kvs(); + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + auto kvs = OpenTestKvs(); using Mode = score::os::Stat::Mode; for (const Mode umask : {Mode::kReadWriteExecGroup | Mode::kReadWriteExecOthers, Mode::kNone}) { const auto previous_umask = score::os::Stat::instance().umask(umask); ASSERT_TRUE(previous_umask.has_value()); - const auto result = kvs.write_json_data(new_kvs_json); + const auto result = kvs.WriteJsonData(kNewKvsJson); score::cpp::ignore = score::os::Stat::instance().umask(previous_umask.value()); ASSERT_TRUE(result); - EXPECT_EQ(file_perms(json_path), static_cast(expected_file_perms)); - EXPECT_EQ(file_perms(hash_path), static_cast(expected_file_perms)); + EXPECT_EQ(FilePerms(json_path), static_cast(kExpectedFilePerms)); + EXPECT_EQ(FilePerms(hash_path), static_cast(kExpectedFilePerms)); } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_sets_file_permissions) { - prepare_environment(); + PrepareEnvironment(); // Test newly created JSON and hash files have 0640 permissions. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - const auto fs{real_filesystem()}; + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + const auto fs{RealFilesystem()}; ASSERT_TRUE(fs.standard->Remove(json_path)); ASSERT_TRUE(fs.standard->Remove(hash_path)); - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - kvs->filename_prefix_ = score::filesystem::Path(filename_prefix); - ASSERT_TRUE(kvs->write_json_data(kvs_json)); - EXPECT_EQ(file_perms(json_path), static_cast(expected_file_perms)); - EXPECT_EQ(file_perms(hash_path), static_cast(expected_file_perms)); + kvs->filename_prefix_ = score::filesystem::Path(kFilenamePrefix); + ASSERT_TRUE(kvs->WriteJsonData(kKvsJson)); + EXPECT_EQ(FilePerms(json_path), static_cast(kExpectedFilePerms)); + EXPECT_EQ(FilePerms(hash_path), static_cast(kExpectedFilePerms)); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_write_json_data, write_json_data_overrides_existing_file_permissions) { - prepare_environment(); + PrepareEnvironment(); // Test existing JSON and hash files with wider permissions are narrowed to 0640. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - const auto fs{real_filesystem()}; + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + const auto fs{RealFilesystem()}; constexpr Perms all_perms{Perms::kReadWriteExecUser | Perms::kReadWriteExecGroup | Perms::kReadWriteExecOthers}; ASSERT_TRUE(fs.standard->Permissions(json_path, all_perms)); ASSERT_TRUE(fs.standard->Permissions(hash_path, all_perms)); - ASSERT_EQ(file_perms(json_path), static_cast(all_perms)); - ASSERT_EQ(file_perms(hash_path), static_cast(all_perms)); - - auto kvs = Kvs::open(InstanceId(instance_id), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + ASSERT_EQ(FilePerms(json_path), static_cast(all_perms)); + ASSERT_EQ(FilePerms(hash_path), static_cast(all_perms)); + + auto kvs = Kvs::Open(InstanceId(kInstanceId), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - kvs->filename_prefix_ = score::filesystem::Path(filename_prefix); - ASSERT_TRUE(kvs->write_json_data(kvs_json)); - EXPECT_EQ(file_perms(json_path), static_cast(expected_file_perms)); - EXPECT_EQ(file_perms(hash_path), static_cast(expected_file_perms)); + kvs->filename_prefix_ = score::filesystem::Path(kFilenamePrefix); + ASSERT_TRUE(kvs->WriteJsonData(kKvsJson)); + EXPECT_EQ(FilePerms(json_path), static_cast(kExpectedFilePerms)); + EXPECT_EQ(FilePerms(hash_path), static_cast(kExpectedFilePerms)); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_rotate, snapshot_rotate_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; - EXPECT_EQ(result.value().snapshot_count().value(), i + 1); + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; + EXPECT_EQ(result.value().SnapshotCount().value(), i + 1); } - ASSERT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".json")); - ASSERT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".hash")); + ASSERT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".json")); + ASSERT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".hash")); // Rotate snapshots. - auto rotate_result = result.value().snapshot_rotate(); + auto rotate_result = result.value().SnapshotRotate(); ASSERT_TRUE(rotate_result); // Check if the snapshot ids are rotated and no ID 0 exists. - EXPECT_TRUE(std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".json")); - EXPECT_TRUE(std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".hash")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(0) + ".json")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(0) + ".hash")); + EXPECT_TRUE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".json")); + EXPECT_TRUE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".hash")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(0) + ".json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(0) + ".hash")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_rotate, snapshot_rotate_max_snapshots) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; - EXPECT_EQ(result.value().snapshot_count().value(), i + 1); + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; + EXPECT_EQ(result.value().SnapshotCount().value(), i + 1); } - ASSERT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".json")); - ASSERT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".hash")); + ASSERT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".json")); + ASSERT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".hash")); - // Check if no ID higher than KVS_DEFAULT_MAX_SNAPSHOTS exists. - auto rotate_result = result.value().snapshot_rotate(); + // Check if no ID higher than kDefaultMaxSnapshots exists. + auto rotate_result = result.value().SnapshotRotate(); ASSERT_TRUE(rotate_result); - EXPECT_FALSE( - std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS + 1) + ".json")); - EXPECT_FALSE( - std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS + 1) + ".hash")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots + 1) + ".json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots + 1) + ".hash")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_rotate, snapshot_rotate_failure_renaming_json) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; - EXPECT_EQ(result.value().snapshot_count().value(), i + 1); + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; + EXPECT_EQ(result.value().SnapshotCount().value(), i + 1); } // Snapshot (JSON) renaming failed (create directories instead of JSON files to trigger a rename error). - std::filesystem::create_directory(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".json"); - auto rotate_result = result.value().snapshot_rotate(); + std::filesystem::create_directory(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".json"); + auto rotate_result = result.value().SnapshotRotate(); EXPECT_FALSE(rotate_result); - EXPECT_EQ(static_cast(*rotate_result.error()), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(static_cast(*rotate_result.error()), ErrorCode::kPhysicalStorageFailure); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_rotate, snapshot_rotate_failure_renaming_hash) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; - EXPECT_EQ(result.value().snapshot_count().value(), i + 1); + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; + EXPECT_EQ(result.value().SnapshotCount().value(), i + 1); } // Hash renaming failed (create directories instead of JSON files to trigger a rename error). - std::filesystem::create_directory(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS) + ".hash"); - auto rotate_result = result.value().snapshot_rotate(); + std::filesystem::create_directory(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots) + ".hash"); + auto rotate_result = result.value().SnapshotRotate(); EXPECT_FALSE(rotate_result); - EXPECT_EQ(static_cast(*rotate_result.error()), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(static_cast(*rotate_result.error()), ErrorCode::kPhysicalStorageFailure); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_rotate, snapshot_rotate_failure_mutex) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Mutex locked. std::unique_lock lock(result.value().kvs_mutex_); - auto rotate_result = result.value().snapshot_rotate(); + auto rotate_result = result.value().SnapshotRotate(); EXPECT_FALSE(rotate_result); - EXPECT_EQ(static_cast(*rotate_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*rotate_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_success_data) { - prepare_environment(); + PrepareEnvironment(); // Test flush with valid data. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Clear KVS to ensure no data is written. result.value().kvs_.clear(); std::string value = "value1"; result.value().kvs_.insert({"key1", KvsValue(value)}); - auto flush_result = result.value().flush(); + auto flush_result = result.value().Flush(); ASSERT_TRUE(flush_result); // Check if files were created correctly. - EXPECT_TRUE(std::filesystem::exists(kvs_prefix + ".json")); - EXPECT_TRUE(std::filesystem::exists(kvs_prefix + ".hash")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_1.json")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_1.hash")); + EXPECT_TRUE(std::filesystem::exists(kKvsPrefix + ".json")); + EXPECT_TRUE(std::filesystem::exists(kKvsPrefix + ".hash")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_1.json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_1.hash")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_success_snapshot_rotate) { - prepare_environment(); + PrepareEnvironment(); // Test flush with valid data. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_1.json")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_1.hash")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_1.json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_1.hash")); // Initial flush -> snapshot ID 0. - score::cpp::ignore = result.value().flush(); + score::cpp::ignore = result.value().Flush(); - // Check if snapshot_rotate was triggered on second flush --> one snapshot should be available afterwards. - auto flush_result = result.value().flush(); + // Check if SnapshotRotate was triggered on second flush --> one snapshot should be available afterwards. + auto flush_result = result.value().Flush(); ASSERT_TRUE(flush_result); - EXPECT_TRUE(std::filesystem::exists(filename_prefix + "_1.json")); - EXPECT_TRUE(std::filesystem::exists(filename_prefix + "_1.hash")); + EXPECT_TRUE(std::filesystem::exists(kFilenamePrefix + "_1.json")); + EXPECT_TRUE(std::filesystem::exists(kFilenamePrefix + "_1.hash")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_sets_file_permissions) { - prepare_environment(); + PrepareEnvironment(); // Test flush creates JSON and hash files with 0640 permissions. - const score::filesystem::Path json_path{kvs_prefix + ".json"}; - const score::filesystem::Path hash_path{kvs_prefix + ".hash"}; - const auto fs{real_filesystem()}; + const score::filesystem::Path json_path{kKvsPrefix + ".json"}; + const score::filesystem::Path hash_path{kKvsPrefix + ".hash"}; + const auto fs{RealFilesystem()}; ASSERT_TRUE(fs.standard->Remove(json_path)); ASSERT_TRUE(fs.standard->Remove(hash_path)); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::string value = "value1"; result.value().kvs_.insert({"key1", KvsValue(value)}); - ASSERT_TRUE(result.value().flush()); - EXPECT_EQ(file_perms(json_path), static_cast(expected_file_perms)); - EXPECT_EQ(file_perms(hash_path), static_cast(expected_file_perms)); + ASSERT_TRUE(result.value().Flush()); + EXPECT_EQ(FilePerms(json_path), static_cast(kExpectedFilePerms)); + EXPECT_EQ(FilePerms(hash_path), static_cast(kExpectedFilePerms)); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_failure_mutex) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto flush_result = result.value().flush(); + auto flush_result = result.value().Flush(); EXPECT_FALSE(flush_result); - EXPECT_EQ(static_cast(*flush_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*flush_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_failure_rotate_snapshots) @@ -1927,40 +1925,40 @@ TEST(kvs_flush, flush_failure_rotate_snapshots) GTEST_SKIP() << "File permissions are not enforced for root."; } - prepare_environment(); + PrepareEnvironment(); // Test folder for permission handling. - std::string permissions_dir = data_dir + "permissions/"; + std::string permissions_dir = kDataDir + "permissions/"; std::filesystem::create_directories(permissions_dir); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, std::string(permissions_dir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::filesystem::permissions( permissions_dir, std::filesystem::perms::owner_read, std::filesystem::perm_options::replace); - auto flush_result = result.value().flush(); + auto flush_result = result.value().Flush(); ASSERT_FALSE(flush_result); - EXPECT_EQ(static_cast(*flush_result.error()), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(static_cast(*flush_result.error()), ErrorCode::kPhysicalStorageFailure); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_failure_json_writer) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Force error in writer.ToBuffer. @@ -1970,54 +1968,54 @@ TEST(kvs_flush, flush_failure_json_writer) ::testing::Return(score::Result(score::MakeUnexpected(score::json::Error::kUnknownError)))); kvs->writer_ = std::move(mock_writer); - auto result = kvs.value().flush(); + auto result = kvs.value().Flush(); EXPECT_FALSE(result); - EXPECT_EQ(result.error(), ErrorCode::JsonGeneratorError); + EXPECT_EQ(result.error(), ErrorCode::kJsonGeneratorError); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_count, snapshot_count_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - auto count = result.value().snapshot_count(); + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + auto count = result.value().SnapshotCount(); EXPECT_TRUE(count); EXPECT_EQ(count.value(), i + 1); } // Test maximum capacity. - std::ofstream(filename_prefix + "_" + std::to_string(KVS_DEFAULT_MAX_SNAPSHOTS + 1) + ".json") << "{}"; - auto count = result.value().snapshot_count(); + std::ofstream(kFilenamePrefix + "_" + std::to_string(kDefaultMaxSnapshots + 1) + ".json") << "{}"; + auto count = result.value().SnapshotCount(); EXPECT_TRUE(count); - EXPECT_EQ(count.value(), KVS_DEFAULT_MAX_SNAPSHOTS); + EXPECT_EQ(count.value(), kDefaultMaxSnapshots); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_count, snapshot_count_invalid) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Mock filesystem. @@ -2029,22 +2027,22 @@ TEST(kvs_snapshot_count, snapshot_count_invalid) score::Result(score::MakeUnexpected(score::filesystem::ErrorCode::kCouldNotRetrieveStatus)))); kvs.value().filesystem_ = std::make_unique(std::move(mock_filesystem)); - auto result = kvs.value().snapshot_count(); + auto result = kvs.value().SnapshotCount(); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kPhysicalStorageFailure); } TEST(kvs_snapshot_restore, snapshot_restore_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. @@ -2061,110 +2059,110 @@ TEST(kvs_snapshot_restore, snapshot_restore_success) } })"; // Create hash data for json_data. - std::ofstream out(filename_prefix + "_1.json", std::ios::binary); + std::ofstream out(kFilenamePrefix + "_1.json", std::ios::binary); out.write(json_data.data(), json_data.size()); out.close(); - uint32_t hash = adler32(json_data); + uint32_t hash = Adler32(json_data); std::array hash_bytes = {uint8_t((hash >> 24) & 0xFF), uint8_t((hash >> 16) & 0xFF), uint8_t((hash >> 8) & 0xFF), uint8_t((hash) & 0xFF)}; - std::ofstream hash_out(filename_prefix + "_1.hash", std::ios::binary); + std::ofstream hash_out(kFilenamePrefix + "_1.hash", std::ios::binary); hash_out.write(reinterpret_cast(hash_bytes.data()), hash_bytes.size()); hash_out.close(); - auto restore_result = result.value().snapshot_restore(1); + auto restore_result = result.value().SnapshotRestore(1); EXPECT_TRUE(restore_result); EXPECT_TRUE(result.value().kvs_.count("kvs_old")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_restore, snapshot_restore_failure_invalid_snapshot_id) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Restore snapshot ID 0 -> current KVS. - auto restore_result = result.value().snapshot_restore(0); + auto restore_result = result.value().SnapshotRestore(0); ASSERT_FALSE(restore_result); - EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::InvalidSnapshotId); + EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::kInvalidSnapshotId); - // Restore a snapshot ID higher than snapshot_count (e.g. KVS_DEFAULT_MAX_SNAPSHOTS + 1). - restore_result = result.value().snapshot_restore(KVS_DEFAULT_MAX_SNAPSHOTS + 1); + // Restore a snapshot ID higher than SnapshotCount (e.g. kDefaultMaxSnapshots + 1). + restore_result = result.value().SnapshotRestore(kDefaultMaxSnapshots + 1); ASSERT_FALSE(restore_result); - EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::InvalidSnapshotId); + EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::kInvalidSnapshotId); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_restore, snapshot_restore_failure_open_json) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Create empty test snapshot files. // Empty JSON. - std::ofstream(filename_prefix + "_1.json") << "{}"; - // Invalid hash -> trigger open_json() error. - std::ofstream(filename_prefix + "_1.hash") << "invalid_hash"; + std::ofstream(kFilenamePrefix + "_1.json") << "{}"; + // Invalid hash -> trigger OpenJson() error. + std::ofstream(kFilenamePrefix + "_1.hash") << "invalid_hash"; - auto restore_result = result.value().snapshot_restore(1); + auto restore_result = result.value().SnapshotRestore(1); EXPECT_FALSE(restore_result); - // Passed by open_json. - EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::ValidationFailed); + // Passed by OpenJson. + EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::kValidationFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_restore, snapshot_restore_failure_mutex) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); std::unique_lock lock(result.value().kvs_mutex_); - auto restore_result = result.value().snapshot_restore(1); + auto restore_result = result.value().SnapshotRestore(1); EXPECT_FALSE(restore_result); - EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_restore, snapshot_restore_failure_snapshot_count) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Mock filesystem. @@ -2176,75 +2174,75 @@ TEST(kvs_snapshot_restore, snapshot_restore_failure_snapshot_count) score::Result(score::MakeUnexpected(score::filesystem::ErrorCode::kCouldNotRetrieveStatus)))); kvs.value().filesystem_ = std::make_unique(std::move(mock_filesystem)); - auto result = kvs.value().snapshot_restore(1); + auto result = kvs.value().SnapshotRestore(1); EXPECT_FALSE(result); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_max_count, snapshot_max_count) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); - EXPECT_EQ(result.value().snapshot_max_count(), KVS_DEFAULT_MAX_SNAPSHOTS); + EXPECT_EQ(result.value().SnapshotMaxCount(), kDefaultMaxSnapshots); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_filename, get_kvs_filename_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Generate test files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; } - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - auto filename = result.value().get_kvs_filename(SnapshotId(i)); + auto filename = result.value().KvsFilePath(SnapshotId(i)); EXPECT_TRUE(filename); - EXPECT_EQ(filename.value().CStr(), filename_prefix + "_" + std::to_string(i) + ".json"); + EXPECT_EQ(filename.value().CStr(), kFilenamePrefix + "_" + std::to_string(i) + ".json"); } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_filename, get_kvs_filename_failure) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Test files not available. - auto result = kvs.value().get_kvs_filename(SnapshotId(1)); + auto result = kvs.value().KvsFilePath(SnapshotId(1)); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::FileNotFound); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kFileNotFound); // Filesystem exists error. // Mock filesystem. @@ -2256,59 +2254,59 @@ TEST(kvs_get_filename, get_kvs_filename_failure) score::Result(score::MakeUnexpected(score::filesystem::ErrorCode::kCouldNotRetrieveStatus)))); kvs.value().filesystem_ = std::make_unique(std::move(mock_filesystem)); - result = kvs.value().get_kvs_filename(SnapshotId(1)); + result = kvs.value().KvsFilePath(SnapshotId(1)); EXPECT_FALSE(result); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_filename, get_hashname_success) { - prepare_environment(); + PrepareEnvironment(); - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result); // Generate test files. - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; } - for (size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (size_t i = 0; i < kDefaultMaxSnapshots; i++) { - auto hashname = result.value().get_hash_filename(SnapshotId(i)); + auto hashname = result.value().HashFilePath(SnapshotId(i)); system("ls -l ./data_folder/"); EXPECT_TRUE(hashname); - EXPECT_EQ(hashname.value().CStr(), filename_prefix + "_" + std::to_string(i) + ".hash"); + EXPECT_EQ(hashname.value().CStr(), kFilenamePrefix + "_" + std::to_string(i) + ".hash"); } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_filename, get_hashname_failure) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Test files not available. - auto result = kvs.value().get_hash_filename(SnapshotId(1)); + auto result = kvs.value().HashFilePath(SnapshotId(1)); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::FileNotFound); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kFileNotFound); // Filesystem exists error. // Mock filesystem. @@ -2320,387 +2318,387 @@ TEST(kvs_get_filename, get_hashname_failure) score::Result(score::MakeUnexpected(score::filesystem::ErrorCode::kCouldNotRetrieveStatus)))); kvs.value().filesystem_ = std::make_unique(std::move(mock_filesystem)); - result = kvs.value().get_hash_filename(SnapshotId(1)); + result = kvs.value().HashFilePath(SnapshotId(1)); EXPECT_FALSE(result); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_remove_all_keys, remove_all_keys_removes_inserted_keys) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Insert some test key-value pairs. for (int i = 0; i < 5; i++) { - auto set_result = kvs.value().set_value("key" + std::to_string(i), KvsValue(i)); + auto set_result = kvs.value().SetValue("key" + std::to_string(i), KvsValue(i)); EXPECT_TRUE(set_result); } // Remove all keys. - auto result = kvs.value().remove_all_keys(); + auto result = kvs.value().RemoveAllKeys(); EXPECT_TRUE(result); // Verify that all keys are removed. for (int i = 0; i < 5; i++) { - auto get_result = kvs.value().get_value("key" + std::to_string(i)); + auto get_result = kvs.value().GetValue("key" + std::to_string(i)); EXPECT_FALSE(get_result); - EXPECT_EQ(static_cast(*get_result.error()), ErrorCode::KeyNotFound); + EXPECT_EQ(static_cast(*get_result.error()), ErrorCode::kKeyNotFound); } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_remove_all_keys, remove_all_keys_empty_kvs) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); kvs.value().kvs_.clear(); // Removing from an already empty KVS succeeds. - auto result = kvs.value().remove_all_keys(); + auto result = kvs.value().RemoveAllKeys(); EXPECT_TRUE(result); EXPECT_TRUE(kvs.value().kvs_.empty()); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_remove_all_keys, remove_all_keys_keeps_defaults) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); kvs.value().default_values_.insert_or_assign("defaulted", KvsValue(42.0)); - auto set_result = kvs.value().set_value("defaulted", KvsValue(7.0)); + auto set_result = kvs.value().SetValue("defaulted", KvsValue(7.0)); ASSERT_TRUE(set_result); - auto result = kvs.value().remove_all_keys(); + auto result = kvs.value().RemoveAllKeys(); EXPECT_TRUE(result); // Explicit values are gone, defaults are untouched and served instead. EXPECT_TRUE(kvs.value().kvs_.empty()); EXPECT_TRUE(kvs.value().default_values_.count("defaulted")); - auto get_result = kvs.value().get_value("defaulted"); + auto get_result = kvs.value().GetValue("defaulted"); ASSERT_FALSE(get_result); - EXPECT_EQ(static_cast(*get_result.error()), ErrorCode::KeyNotFound); + EXPECT_EQ(static_cast(*get_result.error()), ErrorCode::kKeyNotFound); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_remove_all_keys, remove_all_keys_failure) { - prepare_environment(); + PrepareEnvironment(); // Mutex locked. - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); std::unique_lock lock(kvs.value().kvs_mutex_); - auto result = kvs.value().remove_all_keys(); + auto result = kvs.value().RemoveAllKeys(); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_discard_pending_changes, discard_reverts_to_state_at_open) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - // "kvs" is loaded from the test file by prepare_environment(). + // "kvs" is loaded from the test file by PrepareEnvironment(). ASSERT_TRUE(kvs.value().kvs_.count("kvs")); // Make pending changes of every kind: add, modify, remove. - ASSERT_TRUE(kvs.value().set_value("added", KvsValue(1.0))); - ASSERT_TRUE(kvs.value().set_value("kvs", KvsValue(99.0))); - ASSERT_TRUE(kvs.value().remove_all_keys()); + ASSERT_TRUE(kvs.value().SetValue("added", KvsValue(1.0))); + ASSERT_TRUE(kvs.value().SetValue("kvs", KvsValue(99.0))); + ASSERT_TRUE(kvs.value().RemoveAllKeys()); - auto result = kvs.value().discard_pending_changes(); + auto result = kvs.value().DiscardPendingChanges(); EXPECT_TRUE(result); - // Back to what open() loaded. + // Back to what Open() loaded. EXPECT_FALSE(kvs.value().kvs_.count("added")); ASSERT_TRUE(kvs.value().kvs_.count("kvs")); - auto get_result = kvs.value().get_value("kvs"); + auto get_result = kvs.value().GetValue("kvs"); ASSERT_TRUE(get_result); - EXPECT_EQ(get_result.value().getType(), KvsValue::Type::i32); - EXPECT_EQ(std::get(get_result.value().getValue()), 2); + EXPECT_EQ(get_result.value().GetType(), KvsValue::Type::kI32); + EXPECT_EQ(std::get(get_result.value().GetValue()), 2); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_discard_pending_changes, discard_reverts_to_last_flush) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - ASSERT_TRUE(kvs.value().remove_all_keys()); - ASSERT_TRUE(kvs.value().set_value("kept", KvsValue(1.0))); - ASSERT_TRUE(kvs.value().flush()); + ASSERT_TRUE(kvs.value().RemoveAllKeys()); + ASSERT_TRUE(kvs.value().SetValue("kept", KvsValue(1.0))); + ASSERT_TRUE(kvs.value().Flush()); // Changes made after the flush are the pending ones. - ASSERT_TRUE(kvs.value().set_value("kept", KvsValue(2.0))); - ASSERT_TRUE(kvs.value().set_value("pending", KvsValue(3.0))); + ASSERT_TRUE(kvs.value().SetValue("kept", KvsValue(2.0))); + ASSERT_TRUE(kvs.value().SetValue("pending", KvsValue(3.0))); - auto result = kvs.value().discard_pending_changes(); + auto result = kvs.value().DiscardPendingChanges(); EXPECT_TRUE(result); EXPECT_FALSE(kvs.value().kvs_.count("pending")); - auto get_result = kvs.value().get_value("kept"); + auto get_result = kvs.value().GetValue("kept"); ASSERT_TRUE(get_result); - EXPECT_DOUBLE_EQ(std::get(get_result.value().getValue()), 1.0); + EXPECT_DOUBLE_EQ(std::get(get_result.value().GetValue()), 1.0); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_discard_pending_changes, discard_without_changes_is_noop) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); const auto keys_before = kvs.value().kvs_.size(); - EXPECT_TRUE(kvs.value().discard_pending_changes()); + EXPECT_TRUE(kvs.value().DiscardPendingChanges()); EXPECT_EQ(kvs.value().kvs_.size(), keys_before); // Repeated calls stay stable. - EXPECT_TRUE(kvs.value().discard_pending_changes()); + EXPECT_TRUE(kvs.value().DiscardPendingChanges()); EXPECT_EQ(kvs.value().kvs_.size(), keys_before); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_discard_pending_changes, discard_pending_changes_failure) { - prepare_environment(); + PrepareEnvironment(); // Mutex locked. - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Required, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kRequired, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); std::unique_lock lock(kvs.value().kvs_mutex_); - auto result = kvs.value().discard_pending_changes(); + auto result = kvs.value().DiscardPendingChanges(); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::MutexLockFailed); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kMutexLockFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_discard_pending_changes, discard_without_persisted_file_yields_empty) { - prepare_environment(); + PrepareEnvironment(); // No KVS file: opened as Optional and never flushed. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - ASSERT_TRUE(kvs.value().set_value("pending", KvsValue(1.0))); + ASSERT_TRUE(kvs.value().SetValue("pending", KvsValue(1.0))); - EXPECT_TRUE(kvs.value().discard_pending_changes()); + EXPECT_TRUE(kvs.value().DiscardPendingChanges()); EXPECT_TRUE(kvs.value().kvs_.empty()); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_discard_pending_changes, discard_reports_corrupted_storage) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Corrupt the hash of the persisted file after opening. - std::fstream corrupt_hash_file(kvs_prefix + ".hash", std::ios::in | std::ios::out | std::ios::binary); + std::fstream corrupt_hash_file(kKvsPrefix + ".hash", std::ios::in | std::ios::out | std::ios::binary); corrupt_hash_file.seekp(0); corrupt_hash_file.put(0xFF); corrupt_hash_file.close(); - auto result = kvs.value().discard_pending_changes(); + auto result = kvs.value().DiscardPendingChanges(); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::ValidationFailed); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kValidationFailed); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_storage_file_size, size_matches_files_on_disk) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Required, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kRequired, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); const auto expected = - std::filesystem::file_size(kvs_prefix + ".json") + std::filesystem::file_size(kvs_prefix + ".hash"); + std::filesystem::file_size(kKvsPrefix + ".json") + std::filesystem::file_size(kKvsPrefix + ".hash"); - auto result = kvs.value().get_storage_file_size(); + auto result = kvs.value().GetStorageFileSize(); ASSERT_TRUE(result); EXPECT_EQ(result.value(), expected); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_storage_file_size, size_without_files_is_zero) { - prepare_environment(); + PrepareEnvironment(); - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); - auto result = kvs.value().get_storage_file_size(); + auto result = kvs.value().GetStorageFileSize(); ASSERT_TRUE(result); EXPECT_EQ(result.value(), 0U); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_storage_file_size, size_reflects_storage_not_pending_changes) { - prepare_environment(); + PrepareEnvironment(); - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // Unflushed changes are invisible to the size query. - ASSERT_TRUE(kvs.value().set_value("pending", KvsValue(1.0))); - auto before = kvs.value().get_storage_file_size(); + ASSERT_TRUE(kvs.value().SetValue("pending", KvsValue(1.0))); + auto before = kvs.value().GetStorageFileSize(); ASSERT_TRUE(before); EXPECT_EQ(before.value(), 0U); - ASSERT_TRUE(kvs.value().flush()); + ASSERT_TRUE(kvs.value().Flush()); - auto after = kvs.value().get_storage_file_size(); + auto after = kvs.value().GetStorageFileSize(); ASSERT_TRUE(after); EXPECT_GT(after.value(), 0U); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_get_storage_file_size, size_failure_unreadable_path) { - prepare_environment(); + PrepareEnvironment(); - auto kvs = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto kvs = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(kvs); // A directory in place of the data file cannot be sized as a regular file. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - std::filesystem::create_directory(kvs_prefix + ".json"); + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + std::filesystem::create_directory(kKvsPrefix + ".json"); - auto result = kvs.value().get_storage_file_size(); + auto result = kvs.value().GetStorageFileSize(); EXPECT_FALSE(result); - EXPECT_EQ(static_cast(*result.error()), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(static_cast(*result.error()), ErrorCode::kPhysicalStorageFailure); - cleanup_environment(); + CleanupEnvironment(); } /// @brief Storage limit used by the max-size tests. @@ -2715,17 +2713,17 @@ TEST(kvs_max_storage_bytes, flush_succeeds_without_configured_limit) const std::string test_dir = "./kvs_no_limit_test/"; std::filesystem::remove_all(test_dir); - KvsBuilder builder(instance_id); - builder.dir(std::string(test_dir)); - auto open_res = builder.build(); + KvsBuilder builder(kInstanceId); + builder.WorkingDir(std::string(test_dir)); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); const std::string large_data(kTestMaxStorageBytes * 4U, 'a'); - auto set_res = kvs.set_value("large_data", KvsValue(large_data.c_str())); + auto set_res = kvs.SetValue("large_data", KvsValue(large_data.c_str())); ASSERT_TRUE(set_res); - auto flush_res = kvs.flush(); + auto flush_res = kvs.Flush(); EXPECT_TRUE(flush_res); std::filesystem::remove_all(test_dir); @@ -2736,10 +2734,10 @@ TEST(kvs_max_storage_bytes, flush_fails_when_storage_limit_exceeded) const std::string test_dir = "./kvs_storage_test/"; std::filesystem::remove_all(test_dir); - KvsBuilder builder(instance_id); - builder.dir(std::string(test_dir)); - builder.max_storage_bytes(kTestMaxStorageBytes); - auto open_res = builder.build(); + KvsBuilder builder(kInstanceId); + builder.WorkingDir(std::string(test_dir)); + builder.MaxStorageBytes(kTestMaxStorageBytes); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); @@ -2749,20 +2747,20 @@ TEST(kvs_max_storage_bytes, flush_fails_when_storage_limit_exceeded) const size_t overhead_estimate = 100U; const std::string large_data(kTestMaxStorageBytes - overhead_estimate, 'a'); - auto set_res1 = kvs.set_value("large_data", KvsValue(large_data.c_str())); + auto set_res1 = kvs.SetValue("large_data", KvsValue(large_data.c_str())); ASSERT_TRUE(set_res1); // The first flush still fits. - auto flush_res1 = kvs.flush(); + auto flush_res1 = kvs.Flush(); ASSERT_TRUE(flush_res1); // A little more data pushes the total over the limit. - auto set_res2 = kvs.set_value("extra_data", KvsValue("this should not fit")); + auto set_res2 = kvs.SetValue("extra_data", KvsValue("this should not fit")); ASSERT_TRUE(set_res2); - auto flush_res2 = kvs.flush(); + auto flush_res2 = kvs.Flush(); ASSERT_FALSE(flush_res2); - EXPECT_EQ(static_cast(*flush_res2.error()), ErrorCode::OutOfStorageSpace); + EXPECT_EQ(static_cast(*flush_res2.error()), ErrorCode::kOutOfStorageSpace); std::filesystem::remove_all(test_dir); } @@ -2773,17 +2771,17 @@ TEST(kvs_check_size, check_size_within_limit_succeeds) std::filesystem::remove_all(test_dir); KvsBuilder builder(InstanceId(1)); - builder.dir(std::string(test_dir)); - builder.max_storage_bytes(kTestMaxStorageBytes); - auto open_res = builder.build(); + builder.WorkingDir(std::string(test_dir)); + builder.MaxStorageBytes(kTestMaxStorageBytes); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); - auto set_res = kvs.set_value("key", KvsValue("some_data")); + auto set_res = kvs.SetValue("key", KvsValue("some_data")); ASSERT_TRUE(set_res); - auto check_res = kvs.calculate_potential_size(); - ASSERT_TRUE(check_res) << "calculate_potential_size should succeed for data within limits"; + auto check_res = kvs.CalculatePotentialSize(); + ASSERT_TRUE(check_res) << "CalculatePotentialSize should succeed for data within limits"; EXPECT_GT(check_res.value(), 0U); EXPECT_LT(check_res.value(), kTestMaxStorageBytes); @@ -2796,45 +2794,45 @@ TEST(kvs_check_size, check_size_exceeding_limit_fails) std::filesystem::remove_all(test_dir); KvsBuilder builder(InstanceId(2)); - builder.dir(std::string(test_dir)); - builder.max_storage_bytes(kTestMaxStorageBytes); - auto open_res = builder.build(); + builder.WorkingDir(std::string(test_dir)); + builder.MaxStorageBytes(kTestMaxStorageBytes); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); const std::string large_data(kTestMaxStorageBytes, 'x'); - auto set_res = kvs.set_value("oversized_key", KvsValue(large_data.c_str())); + auto set_res = kvs.SetValue("oversized_key", KvsValue(large_data.c_str())); ASSERT_TRUE(set_res); - auto check_res = kvs.calculate_potential_size(); - ASSERT_FALSE(check_res) << "calculate_potential_size should fail when the storage limit is exceeded"; - EXPECT_EQ(static_cast(*check_res.error()), ErrorCode::OutOfStorageSpace); + auto check_res = kvs.CalculatePotentialSize(); + ASSERT_FALSE(check_res) << "CalculatePotentialSize should fail when the storage limit is exceeded"; + EXPECT_EQ(static_cast(*check_res.error()), ErrorCode::kOutOfStorageSpace); std::filesystem::remove_all(test_dir); } TEST(kvs_max_storage_bytes, flush_without_limit_does_not_measure_storage) { - // Without a configured limit, flush() must not measure the persisted files at all. + // Without a configured limit, Flush() must not measure the persisted files at all. // A KVS that does not use the limit then behaves exactly as before this feature existed. // A directory placed where a defaults file is expected makes any size measurement fail. // A successful flush here proves that no measurement happened. const std::string test_dir = "./kvs_no_limit_no_measure_test/"; std::filesystem::remove_all(test_dir); - KvsBuilder builder(instance_id); - builder.dir(std::string(test_dir)); - auto open_res = builder.build(); + KvsBuilder builder(kInstanceId); + builder.WorkingDir(std::string(test_dir)); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); - // Obstruct the measurement only after opening, so open() itself is unaffected. - std::filesystem::create_directories(test_dir + "kvs_" + std::to_string(instance) + "_default.hash"); + // Obstruct the measurement only after opening, so Open() itself is unaffected. + std::filesystem::create_directories(test_dir + "kvs_" + std::to_string(kInstance) + "_default.hash"); - auto set_res = kvs.set_value("key", KvsValue("value")); + auto set_res = kvs.SetValue("key", KvsValue("value")); ASSERT_TRUE(set_res); - auto flush_res = kvs.flush(); + auto flush_res = kvs.Flush(); EXPECT_TRUE(flush_res); std::filesystem::remove_all(test_dir); @@ -2843,50 +2841,50 @@ TEST(kvs_max_storage_bytes, flush_without_limit_does_not_measure_storage) TEST(kvs_max_storage_bytes, flush_with_limit_measures_storage) { // Counterpart to flush_without_limit_does_not_measure_storage. - // With a limit set, the same obstruction makes flush() fail, so the obstruction really does break the measurement. + // With a limit set, the same obstruction makes Flush() fail, so the obstruction really does break the measurement. // Without this test, the one above could pass for the wrong reason. // The limit is far above the data size, so the limit itself is not reached. const std::string test_dir = "./kvs_limit_measures_test/"; std::filesystem::remove_all(test_dir); - KvsBuilder builder(instance_id); - builder.dir(std::string(test_dir)); - builder.max_storage_bytes(kTestMaxStorageBytes * 1000U); - auto open_res = builder.build(); + KvsBuilder builder(kInstanceId); + builder.WorkingDir(std::string(test_dir)); + builder.MaxStorageBytes(kTestMaxStorageBytes * 1000U); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); - std::filesystem::create_directories(test_dir + "kvs_" + std::to_string(instance) + "_default.hash"); + std::filesystem::create_directories(test_dir + "kvs_" + std::to_string(kInstance) + "_default.hash"); - auto set_res = kvs.set_value("key", KvsValue("value")); + auto set_res = kvs.SetValue("key", KvsValue("value")); ASSERT_TRUE(set_res); - auto flush_res = kvs.flush(); + auto flush_res = kvs.Flush(); ASSERT_FALSE(flush_res); - EXPECT_EQ(static_cast(*flush_res.error()), ErrorCode::PhysicalStorageFailure); + EXPECT_EQ(static_cast(*flush_res.error()), ErrorCode::kPhysicalStorageFailure); std::filesystem::remove_all(test_dir); } TEST(kvs_check_size, check_size_without_limit_reports_size) { - // calculate_potential_size() shares serialize_and_check() with flush(). + // CalculatePotentialSize() shares SerializeAndCheck() with Flush(). // Skipping the measurement there when no limit is set must not stop the dry run from reporting a size. // Without a limit, it measures on its own and returns a real, non-zero size. const std::string test_dir = "./kvs_check_size_no_limit_test/"; std::filesystem::remove_all(test_dir); KvsBuilder builder(InstanceId(3)); - builder.dir(std::string(test_dir)); - auto open_res = builder.build(); + builder.WorkingDir(std::string(test_dir)); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); - auto set_res = kvs.set_value("key", KvsValue("some_data")); + auto set_res = kvs.SetValue("key", KvsValue("some_data")); ASSERT_TRUE(set_res); - auto check_res = kvs.calculate_potential_size(); - ASSERT_TRUE(check_res) << "calculate_potential_size should succeed when no limit is configured"; + auto check_res = kvs.CalculatePotentialSize(); + ASSERT_TRUE(check_res) << "CalculatePotentialSize should succeed when no limit is configured"; EXPECT_GT(check_res.value(), 0U); std::filesystem::remove_all(test_dir); @@ -2900,37 +2898,37 @@ TEST(kvs_check_size, check_size_without_limit_reports_size) TEST(kvs_snapshot_max_count, snapshot_max_count_configurable) { - prepare_environment(); + PrepareEnvironment(); // The reported maximum must be the configured one, not the compile-time default. - for (const std::size_t configured_max : {std::size_t{0U}, std::size_t{1U}, KVS_MAX_SNAPSHOTS_UPPER_BOUND}) + for (const std::size_t configured_max : {std::size_t{0U}, std::size_t{1U}, kMaxSnapshotsUpperBound}) { - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, configured_max); ASSERT_TRUE(result); - EXPECT_EQ(result.value().snapshot_max_count(), configured_max); + EXPECT_EQ(result.value().SnapshotMaxCount(), configured_max); } - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_rotate, snapshot_rotate_respects_configured_max) { - prepare_environment(); + PrepareEnvironment(); // Rotation must stop at the configured maximum. // A configuration that is only reported but not enforced would leave this snapshot behind. const std::size_t configured_max = 1U; - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, configured_max); ASSERT_TRUE(result); @@ -2939,202 +2937,197 @@ TEST(kvs_snapshot_rotate, snapshot_rotate_respects_configured_max) // Tag them, so that the rotation can be followed by content and not only by existence. for (std::size_t i = 0; i <= configured_max; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{\"gen\":" << i << "}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{\"gen\":" << i << "}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; } - auto rotate_result = result.value().snapshot_rotate(); + auto rotate_result = result.value().SnapshotRotate(); ASSERT_TRUE(rotate_result); // Rotation happened: the current KVS moved into the first snapshot slot and vacated slot 0. // Without this the test would also pass if nothing rotated. - EXPECT_TRUE(std::filesystem::exists(filename_prefix + "_1.json")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_0.json")); - std::ifstream rotated(filename_prefix + "_1.json"); + EXPECT_TRUE(std::filesystem::exists(kFilenamePrefix + "_1.json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_0.json")); + std::ifstream rotated(kFilenamePrefix + "_1.json"); std::string rotated_content((std::istreambuf_iterator(rotated)), std::istreambuf_iterator()); EXPECT_EQ(rotated_content, "{\"gen\":0}"); // No snapshot beyond the configured maximum may be created. // If rotation used the compile-time default instead of the configured value, _1 would have been rotated into _2. - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(configured_max + 1U) + ".json")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_" + std::to_string(configured_max + 1U) + ".hash")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(configured_max + 1U) + ".json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(configured_max + 1U) + ".hash")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_count, snapshot_count_caps_at_configured_max) { - prepare_environment(); + PrepareEnvironment(); // Counting must use the configured maximum as upper bound. // Otherwise, the count could report snapshots that rotation is not allowed to maintain. const std::size_t configured_max = 1U; - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, configured_max); ASSERT_TRUE(result); - for (std::size_t i = 0; i < KVS_DEFAULT_MAX_SNAPSHOTS; i++) + for (std::size_t i = 0; i < kDefaultMaxSnapshots; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; } - auto count = result.value().snapshot_count(); + auto count = result.value().SnapshotCount(); ASSERT_TRUE(count); EXPECT_EQ(count.value(), configured_max); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_flush, flush_zero_snapshots_still_persists_current_data) { - prepare_environment(); + PrepareEnvironment(); // A maximum of zero snapshots means no previous generation is kept, NOT that persistency is disabled. // The current KVS data is still written. // This matches the Rust backend, whose flush() rotates (a no-op at 0) and then always saves snapshot 0. - system(("rm -rf " + kvs_prefix + ".json").c_str()); - system(("rm -rf " + kvs_prefix + ".hash").c_str()); - - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), - std::nullopt, - 0U); + system(("rm -rf " + kKvsPrefix + ".json").c_str()); + system(("rm -rf " + kKvsPrefix + ".hash").c_str()); + + auto result = Kvs::Open( + kInstanceId, kSnapshotId, KvsDefaults::kOptional, KvsLoad::kOptional, std::string(kDataDir), std::nullopt, 0U); ASSERT_TRUE(result); std::string value = "value1"; result.value().kvs_.insert({"key1", KvsValue(value)}); // The current KVS is persisted ... - auto flush_result = result.value().flush(); + auto flush_result = result.value().Flush(); EXPECT_TRUE(flush_result); - EXPECT_TRUE(std::filesystem::exists(kvs_prefix + ".json")); - EXPECT_TRUE(std::filesystem::exists(kvs_prefix + ".hash")); + EXPECT_TRUE(std::filesystem::exists(kKvsPrefix + ".json")); + EXPECT_TRUE(std::filesystem::exists(kKvsPrefix + ".hash")); // ... but no previous generation is ever created ... - auto second_flush_result = result.value().flush(); + auto second_flush_result = result.value().Flush(); EXPECT_TRUE(second_flush_result); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_1.json")); - EXPECT_FALSE(std::filesystem::exists(filename_prefix + "_1.hash")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_1.json")); + EXPECT_FALSE(std::filesystem::exists(kFilenamePrefix + "_1.hash")); // ... and no snapshot is reported. - auto count = result.value().snapshot_count(); + auto count = result.value().SnapshotCount(); ASSERT_TRUE(count); EXPECT_EQ(count.value(), 0U); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_restore, snapshot_restore_beyond_configured_max) { - prepare_environment(); + PrepareEnvironment(); // Restoring a snapshot outside the configured window must be rejected, even if an older file is still present. const std::size_t configured_max = 1U; - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, configured_max); ASSERT_TRUE(result); for (std::size_t i = 0; i <= configured_max + 1U; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; } - auto restore_result = result.value().snapshot_restore(SnapshotId(configured_max + 1U)); + auto restore_result = result.value().SnapshotRestore(SnapshotId(configured_max + 1U)); ASSERT_FALSE(restore_result); - EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::InvalidSnapshotId); + EXPECT_EQ(static_cast(*restore_result.error()), ErrorCode::kInvalidSnapshotId); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_constructor, move_preserves_snapshot_max_count) { - prepare_environment(); + PrepareEnvironment(); // The configuration is instance state and has to survive both move operations. // The value differs from the default, so a reset to the default would be detected. const std::size_t configured_max = 1U; - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, configured_max); ASSERT_TRUE(result); Kvs kvs_moved = std::move(result.value()); - EXPECT_EQ(kvs_moved.snapshot_max_count(), configured_max); + EXPECT_EQ(kvs_moved.SnapshotMaxCount(), configured_max); - auto result_default = Kvs::open(InstanceId(instance + 1U), - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result_default = Kvs::Open(InstanceId(kInstance + 1U), + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, - KVS_DEFAULT_MAX_SNAPSHOTS); + kDefaultMaxSnapshots); ASSERT_TRUE(result_default); Kvs kvs_assigned = std::move(result_default.value()); - ASSERT_EQ(kvs_assigned.snapshot_max_count(), KVS_DEFAULT_MAX_SNAPSHOTS); + ASSERT_EQ(kvs_assigned.SnapshotMaxCount(), kDefaultMaxSnapshots); kvs_assigned = std::move(kvs_moved); - EXPECT_EQ(kvs_assigned.snapshot_max_count(), configured_max); + EXPECT_EQ(kvs_assigned.SnapshotMaxCount(), configured_max); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_snapshot_max_count, snapshot_max_count_clamped_to_upper_bound) { - prepare_environment(); + PrepareEnvironment(); - // comp_req__kvs__snapshot_max_num_cfg: a request above the range is clamped to KVS_MAX_SNAPSHOTS_UPPER_BOUND. + // comp_req__kvs__snapshot_max_num_cfg: a request above the range is clamped to kMaxSnapshotsUpperBound. // The first value outside the range and a far larger one must both be clamped. // This shows the bound is enforced for every value, not just one. - for (const std::size_t requested : {KVS_MAX_SNAPSHOTS_UPPER_BOUND + 1U, std::size_t{100U}}) + for (const std::size_t requested : {kMaxSnapshotsUpperBound + 1U, std::size_t{100U}}) { - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, requested); ASSERT_TRUE(result); - EXPECT_EQ(result.value().snapshot_max_count(), KVS_MAX_SNAPSHOTS_UPPER_BOUND); + EXPECT_EQ(result.value().SnapshotMaxCount(), kMaxSnapshotsUpperBound); } // Rotation follows the clamped value: no snapshot beyond the upper bound is created. - auto result = Kvs::open(instance_id, - snapshot_id, - OpenNeedDefaults::Optional, - OpenNeedKvs::Optional, - std::string(data_dir), + auto result = Kvs::Open(kInstanceId, + kSnapshotId, + KvsDefaults::kOptional, + KvsLoad::kOptional, + std::string(kDataDir), std::nullopt, 100U); ASSERT_TRUE(result); - for (std::size_t i = 0; i <= KVS_MAX_SNAPSHOTS_UPPER_BOUND; i++) + for (std::size_t i = 0; i <= kMaxSnapshotsUpperBound; i++) { - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".json") << "{}"; - std::ofstream(filename_prefix + "_" + std::to_string(i) + ".hash") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".json") << "{}"; + std::ofstream(kFilenamePrefix + "_" + std::to_string(i) + ".hash") << "{}"; } - ASSERT_TRUE(result.value().snapshot_rotate()); + ASSERT_TRUE(result.value().SnapshotRotate()); EXPECT_FALSE( - std::filesystem::exists(filename_prefix + "_" + std::to_string(KVS_MAX_SNAPSHOTS_UPPER_BOUND + 1U) + ".json")); + std::filesystem::exists(kFilenamePrefix + "_" + std::to_string(kMaxSnapshotsUpperBound + 1U) + ".json")); - cleanup_environment(); + CleanupEnvironment(); } TEST(kvs_max_storage_bytes, storage_size_counts_only_configured_snapshots) @@ -3146,22 +3139,22 @@ TEST(kvs_max_storage_bytes, storage_size_counts_only_configured_snapshots) const std::string test_dir = "./kvs_storage_configured_snapshots_test/"; std::filesystem::remove_all(test_dir); - KvsBuilder builder(instance_id); - builder.dir(std::string(test_dir)); - builder.snapshot_max_count(1U); - builder.max_storage_bytes(kTestMaxStorageBytes); - auto open_res = builder.build(); + KvsBuilder builder(kInstanceId); + builder.WorkingDir(std::string(test_dir)); + builder.SnapshotMaxCount(1U); + builder.MaxStorageBytes(kTestMaxStorageBytes); + auto open_res = builder.Build(); ASSERT_TRUE(open_res); Kvs kvs = std::move(open_res.value()); // A large file in snapshot slot 1, which the next rotation overwrites. std::filesystem::create_directories(test_dir); - std::ofstream(test_dir + "kvs_" + std::to_string(instance) + "_1.json") << std::string(kTestMaxStorageBytes, 'x'); + std::ofstream(test_dir + "kvs_" + std::to_string(kInstance) + "_1.json") << std::string(kTestMaxStorageBytes, 'x'); - auto set_res = kvs.set_value("key", KvsValue("value")); + auto set_res = kvs.SetValue("key", KvsValue("value")); ASSERT_TRUE(set_res); - auto flush_res = kvs.flush(); + auto flush_res = kvs.Flush(); EXPECT_TRUE(flush_res); std::filesystem::remove_all(test_dir); diff --git a/score/kvs/kvs_value.h b/score/kvs/kvs_value.h index 2b877bb17..171b8ced1 100644 --- a/score/kvs/kvs_value.h +++ b/score/kvs/kvs_value.h @@ -30,17 +30,17 @@ namespace score::kvs /// /// The KvsValue class provides a type-safe way to store and retrieve values of different types. /// It uses a std::variant to hold the underlying value and an enum to track the type of the value. -/// Access the underlying value using getValue() and `std::get`. +/// Access the underlying value using GetValue() and `std::get`. /// /// Example: /// @code -/// KvsValue numberValue(42.0); -/// KvsValue stringValue("Hello, World!"); -/// KvsValue arrayValue(KvsValue::Array{numberValue, stringValue}); -/// KvsValue objectValue(KvsValue::Object{{"number", numberValue}, {"text", stringValue}}); +/// KvsValue number_value(42.0); +/// KvsValue string_value("Hello, World!"); +/// KvsValue array_value(KvsValue::Array{number_value, string_value}); +/// KvsValue object_value(KvsValue::Object{{"number", number_value}, {"text", string_value}}); /// -/// if (numberValue.getType() == KvsValue::Type::f64) { -/// double number = std::get(numberValue.getValue()); +/// if (number_value.GetType() == KvsValue::Type::kF64) { +/// double number = std::get(number_value.GetValue()); /// } /// @endcode class KvsValue final @@ -59,76 +59,89 @@ class KvsValue final enum class Type { /// `int32_t` - i32, + kI32 = 0, /// `uint32_t` - u32, + kU32 = 1, /// `int64_t` - i64, + kI64 = 2, /// `uint64_t` - u64, + kU64 = 3, /// `double` - f64, + kF64 = 4, /// `bool` - Boolean, + kBoolean = 5, /// `std::string` - String, + kString = 6, /// `std::nullptr_t` - Null, + kNull = 7, /// KvsValue::Array - Array, + kArray = 8, /// KvsValue::Object - Object + kObject = 9, + + // Deprecated enumerators. + // Each one is an alias of its k-prefixed replacement and is removed in a future release. + i32 [[deprecated("Use kI32 instead. This name is removed in a future release.")]] = kI32, + u32 [[deprecated("Use kU32 instead. This name is removed in a future release.")]] = kU32, + i64 [[deprecated("Use kI64 instead. This name is removed in a future release.")]] = kI64, + u64 [[deprecated("Use kU64 instead. This name is removed in a future release.")]] = kU64, + f64 [[deprecated("Use kF64 instead. This name is removed in a future release.")]] = kF64, + Boolean [[deprecated("Use kBoolean instead. This name is removed in a future release.")]] = kBoolean, + String [[deprecated("Use kString instead. This name is removed in a future release.")]] = kString, + Null [[deprecated("Use kNull instead. This name is removed in a future release.")]] = kNull, + Array [[deprecated("Use kArray instead. This name is removed in a future release.")]] = kArray, + Object [[deprecated("Use kObject instead. This name is removed in a future release.")]] = kObject, }; using ValueVariant = std::variant; /// @brief The Type enumerators must match the order of the variant alternatives. - static_assert(std::is_same_v(Type::i32), ValueVariant>, int32_t>); - static_assert(std::is_same_v(Type::u32), ValueVariant>, uint32_t>); - static_assert(std::is_same_v(Type::i64), ValueVariant>, int64_t>); - static_assert(std::is_same_v(Type::u64), ValueVariant>, uint64_t>); - static_assert(std::is_same_v(Type::f64), ValueVariant>, double>); - static_assert(std::is_same_v(Type::Boolean), ValueVariant>, bool>); + static_assert(std::is_same_v(Type::kI32), ValueVariant>, int32_t>); + static_assert(std::is_same_v(Type::kU32), ValueVariant>, uint32_t>); + static_assert(std::is_same_v(Type::kI64), ValueVariant>, int64_t>); + static_assert(std::is_same_v(Type::kU64), ValueVariant>, uint64_t>); + static_assert(std::is_same_v(Type::kF64), ValueVariant>, double>); + static_assert(std::is_same_v(Type::kBoolean), ValueVariant>, bool>); static_assert( - std::is_same_v(Type::String), ValueVariant>, std::string>); + std::is_same_v(Type::kString), ValueVariant>, std::string>); static_assert( - std::is_same_v(Type::Null), ValueVariant>, std::nullptr_t>); - static_assert(std::is_same_v(Type::Array), ValueVariant>, Array>); - static_assert(std::is_same_v(Type::Object), ValueVariant>, Object>); - static_assert(std::variant_size_v == static_cast(Type::Object) + 1U); + std::is_same_v(Type::kNull), ValueVariant>, std::nullptr_t>); + static_assert(std::is_same_v(Type::kArray), ValueVariant>, Array>); + static_assert(std::is_same_v(Type::kObject), ValueVariant>, Object>); + static_assert(std::variant_size_v == static_cast(Type::kObject) + 1U); - /// @brief Constructs a value of type Type::i32. + /// @brief Constructs a value of type Type::kI32. explicit KvsValue(int32_t number) noexcept : value_(number) {} - /// @brief Constructs a value of type Type::u32. + /// @brief Constructs a value of type Type::kU32. explicit KvsValue(uint32_t number) noexcept : value_(number) {} - /// @brief Constructs a value of type Type::i64. + /// @brief Constructs a value of type Type::kI64. explicit KvsValue(int64_t number) noexcept : value_(number) {} - /// @brief Constructs a value of type Type::u64. + /// @brief Constructs a value of type Type::kU64. explicit KvsValue(uint64_t number) noexcept : value_(number) {} - /// @brief Constructs a value of type Type::f64. + /// @brief Constructs a value of type Type::kF64. explicit KvsValue(double number) noexcept : value_(number) {} - /// @brief Constructs a value of type Type::Boolean. + /// @brief Constructs a value of type Type::kBoolean. explicit KvsValue(bool boolean) noexcept : value_(boolean) {} - /// @brief Constructs a value of type Type::String from a C string. + /// @brief Constructs a value of type Type::kString from a C string. explicit KvsValue(const char* str) noexcept; - /// @brief Constructs a value of type Type::String. + /// @brief Constructs a value of type Type::kString. explicit KvsValue(const std::string& str) noexcept : value_(str) {} - /// @brief Constructs a value of type Type::Null. + /// @brief Constructs a value of type Type::kNull. explicit KvsValue(std::nullptr_t) noexcept : value_(nullptr) {} - /// @brief Constructs a value of type Type::Array by copying the elements. + /// @brief Constructs a value of type Type::kArray by copying the elements. explicit KvsValue(const Array& array) noexcept; - /// @brief Constructs a value of type Type::Array by moving the elements. + /// @brief Constructs a value of type Type::kArray by moving the elements. explicit KvsValue(Array&& array) noexcept; - /// @brief Constructs a value of type Type::Object by copying the members. + /// @brief Constructs a value of type Type::kObject by copying the members. explicit KvsValue(const Object& object) noexcept; - /// @brief Constructs a value of type Type::Object by moving the members. + /// @brief Constructs a value of type Type::kObject by moving the members. explicit KvsValue(Object&& object) noexcept; - /// @brief Constructs a value of type Type::Object from a map. + /// @brief Constructs a value of type Type::kObject from a map. explicit KvsValue(const std::unordered_map& object) noexcept; /// @brief Copy constructor. @@ -148,7 +161,7 @@ class KvsValue final /// @brief Gets the type of the value. /// @return The type of the held value. - Type getType() const noexcept + Type GetType() const noexcept { return static_cast(value_.index()); } @@ -158,11 +171,28 @@ class KvsValue final /// Use `std::get` to retrieve the value. /// /// @return The underlying variant. - const ValueVariant& getValue() const noexcept + const ValueVariant& GetValue() const noexcept { return value_; } + // Deprecated snake_case API. + // Each entry forwards to its PascalCase replacement and is removed in a future release. + + /// @deprecated Use `GetType()` instead. + [[deprecated("Use GetType() instead. This name is removed in a future release.")]] + Type getType() const noexcept + { + return GetType(); + } + + /// @deprecated Use `GetValue()` instead. + [[deprecated("Use GetValue() instead. This name is removed in a future release.")]] + const ValueVariant& getValue() const noexcept + { + return GetValue(); + } + private: /// The underlying value. ValueVariant value_; diff --git a/score/kvs/kvs_value_test.cpp b/score/kvs/kvs_value_test.cpp index 9f53953ea..cdbe94a55 100644 --- a/score/kvs/kvs_value_test.cpp +++ b/score/kvs/kvs_value_test.cpp @@ -34,16 +34,16 @@ TEST(kvs_value_test, get_type_reports_variant) const KvsValue array_value(KvsValue::Array{}); const KvsValue object_value(KvsValue::Object{}); - EXPECT_EQ(signed_32.getType(), KvsValue::Type::i32); - EXPECT_EQ(unsigned_32.getType(), KvsValue::Type::u32); - EXPECT_EQ(signed_64.getType(), KvsValue::Type::i64); - EXPECT_EQ(unsigned_64.getType(), KvsValue::Type::u64); - EXPECT_EQ(floating_point.getType(), KvsValue::Type::f64); - EXPECT_EQ(boolean.getType(), KvsValue::Type::Boolean); - EXPECT_EQ(string_value.getType(), KvsValue::Type::String); - EXPECT_EQ(null_value.getType(), KvsValue::Type::Null); - EXPECT_EQ(array_value.getType(), KvsValue::Type::Array); - EXPECT_EQ(object_value.getType(), KvsValue::Type::Object); + EXPECT_EQ(signed_32.GetType(), KvsValue::Type::kI32); + EXPECT_EQ(unsigned_32.GetType(), KvsValue::Type::kU32); + EXPECT_EQ(signed_64.GetType(), KvsValue::Type::kI64); + EXPECT_EQ(unsigned_64.GetType(), KvsValue::Type::kU64); + EXPECT_EQ(floating_point.GetType(), KvsValue::Type::kF64); + EXPECT_EQ(boolean.GetType(), KvsValue::Type::kBoolean); + EXPECT_EQ(string_value.GetType(), KvsValue::Type::kString); + EXPECT_EQ(null_value.GetType(), KvsValue::Type::kNull); + EXPECT_EQ(array_value.GetType(), KvsValue::Type::kArray); + EXPECT_EQ(object_value.GetType(), KvsValue::Type::kObject); } TEST(kvs_value_test, get_type_follows_assignment) @@ -52,14 +52,14 @@ TEST(kvs_value_test, get_type_follows_assignment) const KvsValue text("text"); value = text; - EXPECT_EQ(value.getType(), KvsValue::Type::String); + EXPECT_EQ(value.GetType(), KvsValue::Type::kString); value = KvsValue(KvsValue::Array{}); - EXPECT_EQ(value.getType(), KvsValue::Type::Array); + EXPECT_EQ(value.GetType(), KvsValue::Type::kArray); KvsValue moved_from(std::int32_t{2}); value = std::move(moved_from); - EXPECT_EQ(value.getType(), KvsValue::Type::i32); + EXPECT_EQ(value.GetType(), KvsValue::Type::kI32); } TEST(kvs_value_test, map_constructor_yields_object) @@ -67,8 +67,8 @@ TEST(kvs_value_test, map_constructor_yields_object) const std::unordered_map map{{"key", KvsValue(true)}}; const KvsValue value(map); - ASSERT_EQ(value.getType(), KvsValue::Type::Object); - const auto& object = std::get(value.getValue()); + ASSERT_EQ(value.GetType(), KvsValue::Type::kObject); + const auto& object = std::get(value.GetValue()); ASSERT_EQ(object.size(), 1U); EXPECT_EQ(object.front().first, "key"); } @@ -78,5 +78,5 @@ TEST(kvs_value_test, move_constructor_preserves_type) KvsValue source(std::string{"text"}); KvsValue value(std::move(source)); - EXPECT_EQ(value.getType(), KvsValue::Type::String); + EXPECT_EQ(value.GetType(), KvsValue::Type::kString); } diff --git a/score/kvs/rust_kvs/json_backend.rs b/score/kvs/rust_kvs/json_backend.rs index 7aca8e3af..00271fdcc 100644 --- a/score/kvs/rust_kvs/json_backend.rs +++ b/score/kvs/rust_kvs/json_backend.rs @@ -1084,7 +1084,7 @@ mod json_backend_builder_tests { mod json_backend_tests { use crate::error_code::ErrorCode; use crate::json_backend::{JsonBackend, JsonBackendBuilder}; - use crate::kvs_api::{InstanceId, SnapshotId, KVS_MAX_KEY_LENGTH_BYTES}; + use crate::kvs_api::{InstanceId, SnapshotId, MAX_KEY_LENGTH_BYTES}; use crate::kvs_value::{KvsMap, KvsValue}; use crate::test_utils::tempdir; use std::os::unix::fs::PermissionsExt; @@ -1200,7 +1200,7 @@ mod json_backend_tests { // Keys are placed in JSON as-is - control characters must be escaped. let invalid_keys = vec![ String::new(), - "k".repeat(KVS_MAX_KEY_LENGTH_BYTES + 1), + "k".repeat(MAX_KEY_LENGTH_BYTES + 1), "\\u001f".to_string(), "\\u007f".to_string(), "tab\\tkey".to_string(), diff --git a/score/kvs/rust_kvs/kvs.rs b/score/kvs/rust_kvs/kvs.rs index bfc02b43c..4276c075c 100644 --- a/score/kvs/rust_kvs/kvs.rs +++ b/score/kvs/rust_kvs/kvs.rs @@ -329,7 +329,7 @@ mod kvs_tests { use crate::error_code::ErrorCode; use crate::json_backend::JsonBackendBuilder; use crate::kvs::{Kvs, KvsParameters}; - use crate::kvs_api::{InstanceId, KvsApi, KvsDefaults, KvsLoad, SnapshotId, KVS_MAX_KEY_LENGTH_BYTES}; + use crate::kvs_api::{InstanceId, KvsApi, KvsDefaults, KvsLoad, SnapshotId, MAX_KEY_LENGTH_BYTES}; use crate::kvs_backend::KvsBackend; use crate::kvs_builder::KvsData; use crate::kvs_value::{KvsMap, KvsValue}; @@ -621,7 +621,7 @@ mod kvs_tests { /// Keys that must be rejected - empty, too long or with invalid content. fn invalid_keys() -> Vec { - let mut keys = vec![String::new(), "k".repeat(KVS_MAX_KEY_LENGTH_BYTES + 1)]; + let mut keys = vec![String::new(), "k".repeat(MAX_KEY_LENGTH_BYTES + 1)]; keys.extend(invalid_character_keys()); keys } @@ -761,7 +761,7 @@ mod kvs_tests { let kvs = get_kvs(Box::new(MockBackend), KvsMap::new(), KvsMap::new()); // comp_req__kvs__key_naming: any key consisting of printable ASCII characters is accepted. - // comp_req__kvs__key_length: key of `KVS_MAX_KEY_LENGTH_BYTES` is accepted. + // comp_req__kvs__key_length: key of `MAX_KEY_LENGTH_BYTES` is accepted. let mut valid_keys = vec![ "a".to_string(), "Z".to_string(), @@ -777,7 +777,7 @@ mod kvs_tests { // Boundaries of the allowed range. " ".to_string(), "~".to_string(), - "k".repeat(KVS_MAX_KEY_LENGTH_BYTES), + "k".repeat(MAX_KEY_LENGTH_BYTES), ]; // Every allowed character on its own. valid_keys.extend((0x20u8..=0x7E).map(|b| char::from(b).to_string())); @@ -800,8 +800,8 @@ mod kvs_tests { fn test_set_value_key_too_long() { let kvs = get_kvs(Box::new(MockBackend), KvsMap::new(), KvsMap::new()); - // comp_req__kvs__key_length: a key of `KVS_MAX_KEY_LENGTH_BYTES + 1` bytes is rejected. - let key = "k".repeat(KVS_MAX_KEY_LENGTH_BYTES + 1); + // comp_req__kvs__key_length: a key of `MAX_KEY_LENGTH_BYTES + 1` bytes is rejected. + let key = "k".repeat(MAX_KEY_LENGTH_BYTES + 1); assert!(kvs.set_value(key, 123.4).is_err_and(|e| e == ErrorCode::InvalidKey)); assert!(kvs.get_all_keys().unwrap().is_empty()); } diff --git a/score/kvs/rust_kvs/kvs_api.rs b/score/kvs/rust_kvs/kvs_api.rs index e0a2284e7..2f1cb4776 100644 --- a/score/kvs/rust_kvs/kvs_api.rs +++ b/score/kvs/rust_kvs/kvs_api.rs @@ -15,14 +15,18 @@ use crate::kvs_value::KvsValue; use crate::log::ScoreDebug; /// Maximum key length in bytes. -pub const KVS_MAX_KEY_LENGTH_BYTES: usize = 32; +pub const MAX_KEY_LENGTH_BYTES: usize = 32; + +/// Maximum key length in bytes. +#[deprecated(note = "Use `MAX_KEY_LENGTH_BYTES` instead.")] +pub const KVS_MAX_KEY_LENGTH_BYTES: usize = MAX_KEY_LENGTH_BYTES; /// Validate that: -/// - Key length is in valid range - (0; `KVS_MAX_KEY_LENGTH_BYTES`>. +/// - Key length is in valid range - (0; `MAX_KEY_LENGTH_BYTES`>. /// - Key consists solely of printable ASCII characters (0x20 - 0x7E). pub(crate) fn is_key_valid(key: &str) -> bool { // comp_req__kvs__key_length: disallow empty keys and keys too long. - if key.is_empty() || key.len() > KVS_MAX_KEY_LENGTH_BYTES { + if key.is_empty() || key.len() > MAX_KEY_LENGTH_BYTES { return false; } diff --git a/score/kvs/rust_kvs/lib.rs b/score/kvs/rust_kvs/lib.rs index a294b2aed..d2fc900d3 100644 --- a/score/kvs/rust_kvs/lib.rs +++ b/score/kvs/rust_kvs/lib.rs @@ -150,7 +150,9 @@ pub mod prelude { pub use crate::error_code::ErrorCode; pub use crate::json_backend::{JsonBackend, JsonBackendBuilder}; pub use crate::kvs::Kvs; - pub use crate::kvs_api::{InstanceId, KvsApi, KvsDefaults, KvsLoad, SnapshotId, KVS_MAX_KEY_LENGTH_BYTES}; + #[allow(deprecated)] + pub use crate::kvs_api::KVS_MAX_KEY_LENGTH_BYTES; + pub use crate::kvs_api::{InstanceId, KvsApi, KvsDefaults, KvsLoad, SnapshotId, MAX_KEY_LENGTH_BYTES}; pub use crate::kvs_backend::KvsBackend; pub use crate::kvs_builder::KvsBuilder; pub use crate::kvs_serialize::{KvsDeserialize, KvsSerialize}; diff --git a/score/kvs/tests/test_scenarios/cit/cit.cpp b/score/kvs/tests/test_scenarios/cit/cit.cpp index d6b8af507..9481e4046 100644 --- a/score/kvs/tests/test_scenarios/cit/cit.cpp +++ b/score/kvs/tests/test_scenarios/cit/cit.cpp @@ -18,8 +18,8 @@ #include "cit/snapshots.h" #include "cit/supported_datatypes.h" -ScenarioGroup::Ptr cit_scenario_group() +ScenarioGroup::Ptr CitScenarioGroup() { return ScenarioGroup::Ptr{new ScenarioGroupImpl{ - "cit", {}, {default_values_group(), multiple_kvs_group(), snapshots_group(), supported_datatypes_group()}}}; + "cit", {}, {DefaultValuesGroup(), MultipleKvsGroup(), SnapshotsGroup(), SupportedDatatypesGroup()}}}; } diff --git a/score/kvs/tests/test_scenarios/cit/cit.h b/score/kvs/tests/test_scenarios/cit/cit.h index aaf497892..90f23b92b 100644 --- a/score/kvs/tests/test_scenarios/cit/cit.h +++ b/score/kvs/tests/test_scenarios/cit/cit.h @@ -16,6 +16,6 @@ #include /// @brief Creates a group containing scenarios for CITs. -ScenarioGroup::Ptr cit_scenario_group(); +ScenarioGroup::Ptr CitScenarioGroup(); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_CIT_CIT_H diff --git a/score/kvs/tests/test_scenarios/cit/default_values.cpp b/score/kvs/tests/test_scenarios/cit/default_values.cpp index 72e54d8be..24229bddd 100644 --- a/score/kvs/tests/test_scenarios/cit/default_values.cpp +++ b/score/kvs/tests/test_scenarios/cit/default_values.cpp @@ -33,10 +33,10 @@ const std::string kTargetName{"cpp_test_scenarios::cit::default_values"}; /// @param value_is_default Whether the current value matches the default ("Ok(true)", "Ok(false)" or error string). /// @param default_value String encoding the default value for the key (e.g. "Ok(F64(...))" or error string). /// @param current_value String encoding the current value for the key (e.g. "Ok(F64(...))" or error string). -static void info_log(const std::string& key, - const std::string& value_is_default, - const std::string& default_value, - const std::string& current_value) +static void InfoLog(const std::string& key, + const std::string& value_is_default, + const std::string& default_value, + const std::string& current_value) { TRACING_INFO(kTargetName, std::pair{std::string{"key"}, key}, @@ -52,7 +52,7 @@ static void info_log(const std::string& key, /// @param key The key being queried or modified in the KVS. /// @param value_is_default String encoding whether the current value matches the default. /// @param current_value Current value for the key (e.g. "Ok(F64(...))" or an error such as "Err(KeyNotFound)"). -static void info_log(const std::string& key, const std::string& value_is_default, const std::string& current_value) +static void InfoLog(const std::string& key, const std::string& value_is_default, const std::string& current_value) { TRACING_INFO(kTargetName, std::pair{std::string{"key"}, key}, @@ -60,9 +60,9 @@ static void info_log(const std::string& key, const std::string& value_is_default std::pair{std::string{"current_value"}, current_value}); } -std::string get_value_is_default(const Kvs& kvs, const std::string& key) +std::string ValueIsDefaultStr(const Kvs& kvs, const std::string& key) { - auto result{kvs.is_value_default(key)}; + auto result{kvs.IsValueDefault(key)}; if (result.has_value()) { if (result.value()) @@ -80,14 +80,14 @@ std::string get_value_is_default(const Kvs& kvs, const std::string& key) } } -std::string get_default_value(Kvs& kvs, const std::string& key) +std::string DefaultValueStr(Kvs& kvs, const std::string& key) { - auto result{kvs.get_default_value(key)}; - if (result.has_value() && result.value().getType() == KvsValue::Type::f64) + auto result{kvs.GetDefaultValue(key)}; + if (result.has_value() && result.value().GetType() == KvsValue::Type::kF64) { std::ostringstream oss; oss.precision(1); - oss << std::fixed << std::get(result.value().getValue()); + oss << std::fixed << std::get(result.value().GetValue()); return std::string{"Ok(F64(" + oss.str() + "))"}; } else @@ -96,14 +96,14 @@ std::string get_default_value(Kvs& kvs, const std::string& key) } } -std::string get_current_value(Kvs& kvs, const std::string& key) +std::string CurrentValueStr(Kvs& kvs, const std::string& key) { - auto result{kvs.get_value(key)}; - if (result.has_value() && result.value().getType() == KvsValue::Type::f64) + auto result{kvs.GetValue(key)}; + if (result.has_value() && result.value().GetType() == KvsValue::Type::kF64) { std::ostringstream oss; oss.precision(1); - oss << std::fixed << std::get(result.value().getValue()); + oss << std::fixed << std::get(result.value().GetValue()); return std::string{"Ok(F64(" + oss.str() + "))"}; } else @@ -130,26 +130,26 @@ class DefaultValues final : public Scenario std::string key{"test_number"}; // Create KVS instance with provided params. - auto params{KvsParameters::from_json(input)}; + auto params{KvsParameters::FromJson(input)}; { - auto kvs{kvs_instance(params)}; + auto kvs{KvsInstance(params)}; // Get current value parameters. - std::string value_is_default{get_value_is_default(kvs, key)}; - std::string default_value{get_default_value(kvs, key)}; - std::string current_value{get_current_value(kvs, key)}; + std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + std::string default_value{DefaultValueStr(kvs, key)}; + std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, default_value, current_value); + InfoLog(key, value_is_default, default_value, current_value); // Set value and check value parameters. - auto set_result{kvs.set_value(key, KvsValue{432.1})}; + auto set_result{kvs.SetValue(key, KvsValue{432.1})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; } // Flush KVS. - auto flush_result{kvs.flush()}; + auto flush_result{kvs.Flush()}; if (!flush_result) { throw std::runtime_error{"Failed to flush"}; @@ -158,14 +158,14 @@ class DefaultValues final : public Scenario // Flush and reopen KVS instance to ensure persistency. { - auto kvs{kvs_instance(params)}; + auto kvs{KvsInstance(params)}; // Get current value parameters. - std::string value_is_default{get_value_is_default(kvs, key)}; - std::string default_value{get_default_value(kvs, key)}; - std::string current_value{get_current_value(kvs, key)}; + std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + std::string default_value{DefaultValueStr(kvs, key)}; + std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, default_value, current_value); + InfoLog(key, value_is_default, default_value, current_value); } } }; @@ -186,20 +186,20 @@ class RemoveKey final : public Scenario std::string key{"test_number"}; // Create KVS instance with provided params. - auto params{KvsParameters::from_json(input)}; - auto kvs{kvs_instance(params)}; + auto params{KvsParameters::FromJson(input)}; + auto kvs{KvsInstance(params)}; // Get value parameters before set. { - std::string value_is_default{get_value_is_default(kvs, key)}; - std::string default_value{get_default_value(kvs, key)}; - std::string current_value{get_current_value(kvs, key)}; + std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + std::string default_value{DefaultValueStr(kvs, key)}; + std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, default_value, current_value); + InfoLog(key, value_is_default, default_value, current_value); } // Get value parameters after set. - auto set_result{kvs.set_value(key, KvsValue{432.1})}; + auto set_result{kvs.SetValue(key, KvsValue{432.1})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; @@ -207,26 +207,26 @@ class RemoveKey final : public Scenario // Get current value parameters. { - std::string value_is_default{get_value_is_default(kvs, key)}; - std::string default_value{get_default_value(kvs, key)}; - std::string current_value{get_current_value(kvs, key)}; + std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + std::string default_value{DefaultValueStr(kvs, key)}; + std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, default_value, current_value); + InfoLog(key, value_is_default, default_value, current_value); } // Get value parameters after remove. { - auto remove_result{kvs.remove_key(key)}; + auto remove_result{kvs.RemoveKey(key)}; if (!remove_result) { throw std::runtime_error{"Failed to remove key"}; } - std::string value_is_default{get_value_is_default(kvs, key)}; - std::string default_value{get_default_value(kvs, key)}; - std::string current_value{get_current_value(kvs, key)}; + std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + std::string default_value{DefaultValueStr(kvs, key)}; + std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, default_value, current_value); + InfoLog(key, value_is_default, default_value, current_value); } } }; @@ -246,8 +246,8 @@ class ResetAllKeys final : public Scenario const int num_values{5}; // Create KVS instance with provided params. - auto params{KvsParameters::from_json(input)}; - auto kvs{kvs_instance(params)}; + auto params{KvsParameters::FromJson(input)}; + auto kvs{KvsInstance(params)}; // List of keys and corresponding values. std::vector> key_values; @@ -261,14 +261,14 @@ class ResetAllKeys final : public Scenario { // Get value before set. { - const std::string value_is_default{get_value_is_default(kvs, key)}; - const std::string current_value{get_current_value(kvs, key)}; + const std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + const std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, current_value); + InfoLog(key, value_is_default, current_value); } // Set value. - auto set_result{kvs.set_value(key, KvsValue{value})}; + auto set_result{kvs.SetValue(key, KvsValue{value})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; @@ -276,15 +276,15 @@ class ResetAllKeys final : public Scenario // Get value after set. { - const std::string value_is_default{get_value_is_default(kvs, key)}; - const std::string current_value{get_current_value(kvs, key)}; + const std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + const std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, current_value); + InfoLog(key, value_is_default, current_value); } } // Reset. - auto reset_result{kvs.reset()}; + auto reset_result{kvs.Reset()}; if (!reset_result) { throw std::runtime_error{"Failed to reset KVS instance"}; @@ -293,10 +293,10 @@ class ResetAllKeys final : public Scenario // Get value parameters after reset. for (const auto& [key, _] : key_values) { - const std::string value_is_default{get_value_is_default(kvs, key)}; - const std::string current_value{get_current_value(kvs, key)}; + const std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + const std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, current_value); + InfoLog(key, value_is_default, current_value); } } }; @@ -317,8 +317,8 @@ class ResetSingleKey final : public Scenario const int reset_index{2}; // Create KVS instance with provided params. - auto params{KvsParameters::from_json(input)}; - auto kvs{kvs_instance(params)}; + auto params{KvsParameters::FromJson(input)}; + auto kvs{KvsInstance(params)}; // List of keys and corresponding values. std::vector> key_values; @@ -332,14 +332,14 @@ class ResetSingleKey final : public Scenario { // Get value parameters before set. { - const std::string value_is_default{get_value_is_default(kvs, key)}; - const std::string current_value{get_current_value(kvs, key)}; + const std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + const std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, current_value); + InfoLog(key, value_is_default, current_value); } // Set value. - auto set_result{kvs.set_value(key, KvsValue{value})}; + auto set_result{kvs.SetValue(key, KvsValue{value})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; @@ -347,15 +347,15 @@ class ResetSingleKey final : public Scenario // Get value parameters after set. { - const std::string value_is_default{get_value_is_default(kvs, key)}; - const std::string current_value{get_current_value(kvs, key)}; + const std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + const std::string current_value{CurrentValueStr(kvs, key)}; - info_log(key, value_is_default, current_value); + InfoLog(key, value_is_default, current_value); } } // Reset single key. - auto reset_result{kvs.reset_key(key_values[reset_index].first)}; + auto reset_result{kvs.ResetKey(key_values[reset_index].first)}; if (!reset_result) { throw std::runtime_error{"Failed to reset key"}; @@ -364,9 +364,9 @@ class ResetSingleKey final : public Scenario // Use KVS APIs to get value_is_default and current_value after reset. for (const auto& [key, value] : key_values) { - const std::string value_is_default{get_value_is_default(kvs, key)}; - const std::string current_value{get_current_value(kvs, key)}; - info_log(key, value_is_default, current_value); + const std::string value_is_default{ValueIsDefaultStr(kvs, key)}; + const std::string current_value{CurrentValueStr(kvs, key)}; + InfoLog(key, value_is_default, current_value); } } }; @@ -384,19 +384,19 @@ class Checksum final : public Scenario void run(const std::string& input) const final { // Create KVS instance with provided params. - auto params{KvsParameters::from_json(input)}; + auto params{KvsParameters::FromJson(input)}; auto working_dir{*params.dir}; std::string kvs_path; std::string hash_path; { // Create instance, flush, store paths to files, close instance. - auto kvs{kvs_instance(params)}; - auto flush_result{kvs.flush()}; + auto kvs{KvsInstance(params)}; + auto flush_result{kvs.Flush()}; if (!flush_result) { throw std::runtime_error{"Failed to flush"}; } - std::tie(kvs_path, hash_path) = kvs_hash_paths(working_dir, params.instance_id, SnapshotId{0}); + std::tie(kvs_path, hash_path) = KvsHashPaths(working_dir, params.instance_id, SnapshotId{0}); } TRACING_INFO( @@ -405,7 +405,7 @@ class Checksum final : public Scenario }; /// @brief Creates the default values scenario group. -ScenarioGroup::Ptr default_values_group() +ScenarioGroup::Ptr DefaultValuesGroup() { return ScenarioGroup::Ptr{new ScenarioGroupImpl{"default_values", {std::make_shared(), diff --git a/score/kvs/tests/test_scenarios/cit/default_values.h b/score/kvs/tests/test_scenarios/cit/default_values.h index bc838d24f..bb544651a 100644 --- a/score/kvs/tests/test_scenarios/cit/default_values.h +++ b/score/kvs/tests/test_scenarios/cit/default_values.h @@ -15,6 +15,6 @@ #include -ScenarioGroup::Ptr default_values_group(); +ScenarioGroup::Ptr DefaultValuesGroup(); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_CIT_DEFAULT_VALUES_H diff --git a/score/kvs/tests/test_scenarios/cit/multiple_kvs.cpp b/score/kvs/tests/test_scenarios/cit/multiple_kvs.cpp index 501751ecb..685d13590 100644 --- a/score/kvs/tests/test_scenarios/cit/multiple_kvs.cpp +++ b/score/kvs/tests/test_scenarios/cit/multiple_kvs.cpp @@ -25,7 +25,7 @@ namespace { const std::string kTargetName{"cpp_test_scenarios::multiple_kvs"}; -static void info_log(const std::string& instance, const std::string& keyname, double value) +static void InfoLog(const std::string& instance, const std::string& keyname, double value) { TRACING_INFO(kTargetName, std::pair{std::string{"instance"}, instance}, @@ -60,34 +60,34 @@ class MultipleInstanceIds final : public Scenario } auto& obj{any_res.value().As().value().get()}; - auto params1{KvsParameters::from_object(obj.at("kvs_parameters_1").As().value().get())}; - auto params2{KvsParameters::from_object(obj.at("kvs_parameters_2").As().value().get())}; + auto params1{KvsParameters::FromValue(obj.at("kvs_parameters_1").As().value().get())}; + auto params2{KvsParameters::FromValue(obj.at("kvs_parameters_2").As().value().get())}; { // Create first KVS instance. - auto kvs1{kvs_instance(params1)}; + auto kvs1{KvsInstance(params1)}; // Create second KVS instance. - auto kvs2{kvs_instance(params2)}; + auto kvs2{KvsInstance(params2)}; // Set value to both KVS instances. - auto set_result_1{kvs1.set_value(keyname, KvsValue{value1})}; + auto set_result_1{kvs1.SetValue(keyname, KvsValue{value1})}; if (!set_result_1) { throw std::runtime_error{"Failed to set value"}; } - auto set_result_2{kvs2.set_value(keyname, KvsValue{value2})}; + auto set_result_2{kvs2.SetValue(keyname, KvsValue{value2})}; if (!set_result_2) { throw std::runtime_error{"Failed to set value"}; } // Flush KVS. - auto flush_result_1{kvs1.flush()}; + auto flush_result_1{kvs1.Flush()}; if (!flush_result_1) { throw std::runtime_error{"Failed to flush first instance"}; } - auto flush_result_2{kvs2.flush()}; + auto flush_result_2{kvs2.Flush()}; if (!flush_result_2) { throw std::runtime_error{"Failed to flush second instance"}; @@ -96,22 +96,22 @@ class MultipleInstanceIds final : public Scenario { // Second KVS run. - auto kvs1{kvs_instance(params1)}; - auto kvs2{kvs_instance(params2)}; + auto kvs1{KvsInstance(params1)}; + auto kvs2{KvsInstance(params2)}; - auto value1{kvs1.get_value(keyname)}; + auto value1{kvs1.GetValue(keyname)}; if (!value1) { throw std::runtime_error{"Failed to read value"}; } - info_log("kvs1", keyname, std::get(value1->getValue())); + InfoLog("kvs1", keyname, std::get(value1->GetValue())); - auto value2{kvs2.get_value(keyname)}; + auto value2{kvs2.GetValue(keyname)}; if (!value2) { throw std::runtime_error{"Failed to read value"}; } - info_log("kvs2", keyname, std::get(value2->getValue())); + InfoLog("kvs2", keyname, std::get(value2->GetValue())); } } }; @@ -133,33 +133,33 @@ class SameInstanceIdSameValue final : public Scenario const double value{111.1}; // Parameters. - auto params{KvsParameters::from_json(input)}; + auto params{KvsParameters::FromJson(input)}; { // Create first KVS instance. - auto kvs1{kvs_instance(params)}; + auto kvs1{KvsInstance(params)}; // Create second KVS instance. - auto kvs2{kvs_instance(params)}; + auto kvs2{KvsInstance(params)}; // Set value to both KVS instances. - auto set_result_1{kvs1.set_value(keyname, KvsValue{value})}; + auto set_result_1{kvs1.SetValue(keyname, KvsValue{value})}; if (!set_result_1) { throw std::runtime_error{"Failed to set value"}; } - auto set_result_2{kvs2.set_value(keyname, KvsValue{value})}; + auto set_result_2{kvs2.SetValue(keyname, KvsValue{value})}; if (!set_result_2) { throw std::runtime_error{"Failed to set value"}; } // Flush KVS. - auto flush_result_1{kvs1.flush()}; + auto flush_result_1{kvs1.Flush()}; if (!flush_result_1) { throw std::runtime_error{"Failed to flush first instance"}; } - auto flush_result_2{kvs2.flush()}; + auto flush_result_2{kvs2.Flush()}; if (!flush_result_2) { throw std::runtime_error{"Failed to flush second instance"}; @@ -168,22 +168,22 @@ class SameInstanceIdSameValue final : public Scenario { // Second KVS run. - auto kvs1{kvs_instance(params)}; - auto kvs2{kvs_instance(params)}; + auto kvs1{KvsInstance(params)}; + auto kvs2{KvsInstance(params)}; - auto value1{kvs1.get_value(keyname)}; + auto value1{kvs1.GetValue(keyname)}; if (!value1) { throw std::runtime_error{"Failed to read value"}; } - info_log("kvs1", keyname, std::get(value1->getValue())); + InfoLog("kvs1", keyname, std::get(value1->GetValue())); - auto value2{kvs2.get_value(keyname)}; + auto value2{kvs2.GetValue(keyname)}; if (!value2) { throw std::runtime_error{"Failed to read value"}; } - info_log("kvs2", keyname, std::get(value2->getValue())); + InfoLog("kvs2", keyname, std::get(value2->GetValue())); } } }; @@ -206,33 +206,33 @@ class SameInstanceIdDifferentValue final : public Scenario const double value2{222.2}; // Parameters. - auto params{KvsParameters::from_json(input)}; + auto params{KvsParameters::FromJson(input)}; { // Create first KVS instance. - auto kvs1{kvs_instance(params)}; + auto kvs1{KvsInstance(params)}; // Create second KVS instance. - auto kvs2{kvs_instance(params)}; + auto kvs2{KvsInstance(params)}; // Set value to both KVS instances. - auto set_result_1{kvs1.set_value(keyname, KvsValue{value1})}; + auto set_result_1{kvs1.SetValue(keyname, KvsValue{value1})}; if (!set_result_1) { throw std::runtime_error{"Failed to set value"}; } - auto set_result_2{kvs2.set_value(keyname, KvsValue{value2})}; + auto set_result_2{kvs2.SetValue(keyname, KvsValue{value2})}; if (!set_result_2) { throw std::runtime_error{"Failed to set value"}; } // Flush KVS. - auto flush_result_1{kvs1.flush()}; + auto flush_result_1{kvs1.Flush()}; if (!flush_result_1) { throw std::runtime_error{"Failed to flush first instance"}; } - auto flush_result_2{kvs2.flush()}; + auto flush_result_2{kvs2.Flush()}; if (!flush_result_2) { throw std::runtime_error{"Failed to flush second instance"}; @@ -241,27 +241,27 @@ class SameInstanceIdDifferentValue final : public Scenario { // Second KVS run. - auto kvs1{kvs_instance(params)}; - auto kvs2{kvs_instance(params)}; + auto kvs1{KvsInstance(params)}; + auto kvs2{KvsInstance(params)}; - auto value1{kvs1.get_value(keyname)}; + auto value1{kvs1.GetValue(keyname)}; if (!value1) { throw std::runtime_error{"Failed to read value"}; } - info_log("kvs1", keyname, std::get(value1->getValue())); + InfoLog("kvs1", keyname, std::get(value1->GetValue())); - auto value2{kvs2.get_value(keyname)}; + auto value2{kvs2.GetValue(keyname)}; if (!value2) { throw std::runtime_error{"Failed to read value"}; } - info_log("kvs2", keyname, std::get(value2->getValue())); + InfoLog("kvs2", keyname, std::get(value2->GetValue())); } } }; -ScenarioGroup::Ptr multiple_kvs_group() +ScenarioGroup::Ptr MultipleKvsGroup() { return ScenarioGroup::Ptr{new ScenarioGroupImpl{"multiple_kvs", { diff --git a/score/kvs/tests/test_scenarios/cit/multiple_kvs.h b/score/kvs/tests/test_scenarios/cit/multiple_kvs.h index 47b15e4c4..137bb8b70 100644 --- a/score/kvs/tests/test_scenarios/cit/multiple_kvs.h +++ b/score/kvs/tests/test_scenarios/cit/multiple_kvs.h @@ -15,6 +15,6 @@ #include -ScenarioGroup::Ptr multiple_kvs_group(); +ScenarioGroup::Ptr MultipleKvsGroup(); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_CIT_MULTIPLE_KVS_H diff --git a/score/kvs/tests/test_scenarios/cit/snapshots.cpp b/score/kvs/tests/test_scenarios/cit/snapshots.cpp index 0dd13d211..c94d51dba 100644 --- a/score/kvs/tests/test_scenarios/cit/snapshots.cpp +++ b/score/kvs/tests/test_scenarios/cit/snapshots.cpp @@ -26,7 +26,7 @@ namespace const std::string kTargetName{"cpp_test_scenarios::snapshots::count"}; template -T get_field(const Object& obj, const std::string& field) +T GetField(const Object& obj, const std::string& field) { auto it{obj.find(field)}; if (it == obj.end()) @@ -36,7 +36,7 @@ T get_field(const Object& obj, const std::string& field) return it->second.As().value(); } -Object get_object(const std::string& data) +Object GetObject(const std::string& data) { JsonParser parser; auto from_buffer_result{parser.FromBuffer(data)}; @@ -67,21 +67,21 @@ class SnapshotCount final : public Scenario void run(const std::string& input) const final { - auto obj{get_object(input)}; - auto count{get_field(obj, "count")}; - auto params{KvsParameters::from_json(input)}; + auto obj{GetObject(input)}; + auto count{GetField(obj, "count")}; + auto params{KvsParameters::FromJson(input)}; // Create snapshots. for (int32_t i{0}; i < count; ++i) { - auto kvs{kvs_instance(params)}; - auto set_result{kvs.set_value("counter", KvsValue{i})}; + auto kvs{KvsInstance(params)}; + auto set_result{kvs.SetValue("counter", KvsValue{i})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; } - auto count_result{kvs.snapshot_count()}; + auto count_result{kvs.SnapshotCount()}; if (!count_result) { throw std::runtime_error{"Unable to get snapshot count"}; @@ -90,7 +90,7 @@ class SnapshotCount final : public Scenario TRACING_INFO(kTargetName, std::pair{std::string{"snapshot_count"}, count_result.value()}); // Flush KVS. - auto flush_result{kvs.flush()}; + auto flush_result{kvs.Flush()}; if (!flush_result) { throw std::runtime_error{"Failed to flush"}; @@ -98,8 +98,8 @@ class SnapshotCount final : public Scenario } { - auto kvs{kvs_instance(params)}; - auto count_result{kvs.snapshot_count()}; + auto kvs{KvsInstance(params)}; + auto count_result{kvs.SnapshotCount()}; if (!count_result) { throw std::runtime_error{"Unable to get snapshot count"}; @@ -121,10 +121,10 @@ class SnapshotMaxCount final : public Scenario void run(const std::string& input) const final { - auto params{KvsParameters::from_json(input)}; + auto params{KvsParameters::FromJson(input)}; - auto kvs{kvs_instance(params)}; - TRACING_INFO(kTargetName, std::pair{std::string{"max_count"}, kvs.snapshot_max_count()}); + auto kvs{KvsInstance(params)}; + TRACING_INFO(kTargetName, std::pair{std::string{"max_count"}, kvs.SnapshotMaxCount()}); } }; @@ -140,23 +140,23 @@ class SnapshotRestore final : public Scenario void run(const std::string& input) const final { - auto obj{get_object(input)}; - auto count{get_field(obj, "count")}; - auto snapshot_id{get_field(obj, "snapshot_id")}; - auto params{KvsParameters::from_json(input)}; + auto obj{GetObject(input)}; + auto count{GetField(obj, "count")}; + auto snapshot_id{GetField(obj, "snapshot_id")}; + auto params{KvsParameters::FromJson(input)}; // Create snapshots. for (int32_t i{0}; i < count; ++i) { - auto kvs{kvs_instance(params)}; - auto set_result{kvs.set_value("counter", KvsValue{i})}; + auto kvs{KvsInstance(params)}; + auto set_result{kvs.SetValue("counter", KvsValue{i})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; } // Flush KVS. - auto flush_result{kvs.flush()}; + auto flush_result{kvs.Flush()}; if (!flush_result) { throw std::runtime_error{"Failed to flush"}; @@ -164,21 +164,21 @@ class SnapshotRestore final : public Scenario } { - auto kvs{kvs_instance(params)}; + auto kvs{KvsInstance(params)}; - auto restore_result{kvs.snapshot_restore(snapshot_id)}; + auto restore_result{kvs.SnapshotRestore(snapshot_id)}; TRACING_INFO(kTargetName, std::pair{std::string{"result"}, restore_result ? "Ok(())" : "Err(InvalidSnapshotId)"}); if (restore_result) { - auto get_result{kvs.get_value("counter")}; + auto get_result{kvs.GetValue("counter")}; if (!get_result) { throw std::runtime_error{"Failed to read value"}; } - auto value{std::get(get_result.value().getValue())}; + auto value{std::get(get_result.value().GetValue())}; TRACING_INFO(kTargetName, std::pair{std::string{"value"}, value}); } } @@ -197,25 +197,25 @@ class SnapshotPaths final : public Scenario void run(const std::string& input) const final { - auto obj{get_object(input)}; - auto count{get_field(obj, "count")}; - auto snapshot_id{get_field(obj, "snapshot_id")}; - auto params{KvsParameters::from_json(input)}; + auto obj{GetObject(input)}; + auto count{GetField(obj, "count")}; + auto snapshot_id{GetField(obj, "snapshot_id")}; + auto params{KvsParameters::FromJson(input)}; auto working_dir{*params.dir}; auto instance_id{params.instance_id}; // Create snapshots. for (int32_t i{0}; i < count; ++i) { - auto kvs{kvs_instance(params)}; - auto set_result{kvs.set_value("counter", KvsValue{i})}; + auto kvs{KvsInstance(params)}; + auto set_result{kvs.SetValue("counter", KvsValue{i})}; if (!set_result) { throw std::runtime_error{"Failed to set value"}; } // Flush KVS. - auto flush_result{kvs.flush()}; + auto flush_result{kvs.Flush()}; if (!flush_result) { throw std::runtime_error{"Failed to flush"}; @@ -223,7 +223,7 @@ class SnapshotPaths final : public Scenario } { - auto [kvs_path, hash_path] = kvs_hash_paths(working_dir, instance_id, snapshot_id); + auto [kvs_path, hash_path] = KvsHashPaths(working_dir, instance_id, snapshot_id); TRACING_INFO(kTargetName, std::make_pair(std::string{"kvs_path"}, kvs_path), std::make_pair(std::string{"hash_path"}, hash_path)); @@ -231,7 +231,7 @@ class SnapshotPaths final : public Scenario } }; -ScenarioGroup::Ptr snapshots_group() +ScenarioGroup::Ptr SnapshotsGroup() { return ScenarioGroup::Ptr{new ScenarioGroupImpl{"snapshots", {std::make_shared(), diff --git a/score/kvs/tests/test_scenarios/cit/snapshots.h b/score/kvs/tests/test_scenarios/cit/snapshots.h index 8bcb6bff7..66307ec46 100644 --- a/score/kvs/tests/test_scenarios/cit/snapshots.h +++ b/score/kvs/tests/test_scenarios/cit/snapshots.h @@ -15,6 +15,6 @@ #include -ScenarioGroup::Ptr snapshots_group(); +ScenarioGroup::Ptr SnapshotsGroup(); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_CIT_SNAPSHOTS_H diff --git a/score/kvs/tests/test_scenarios/cit/supported_datatypes.cpp b/score/kvs/tests/test_scenarios/cit/supported_datatypes.cpp index b779fa341..8d6294271 100644 --- a/score/kvs/tests/test_scenarios/cit/supported_datatypes.cpp +++ b/score/kvs/tests/test_scenarios/cit/supported_datatypes.cpp @@ -29,24 +29,24 @@ namespace { const std::string kTargetName{"cpp_test_scenarios::supported_datatypes"}; -void info_log_set_result(const std::string& keyname, bool set_ok) +void InfoLogSetResult(const std::string& keyname, bool set_ok) { TRACING_INFO(kTargetName, std::make_pair(std::string("key"), keyname), std::make_pair(std::string("set_ok"), std::string(set_ok ? "true" : "false"))); } -void info_log_stored_key(const std::string& keyname) +void InfoLogStoredKey(const std::string& keyname) { TRACING_INFO(kTargetName, std::make_pair(std::string("stored_key"), keyname)); } -void info_log(const std::string& name, const std::string& value) +void InfoLog(const std::string& name, const std::string& value) { TRACING_INFO(kTargetName, std::make_pair(std::string(name), value)); } -void info_log(const std::string& key, - const std::string& key_value, - const std::string& value, - const std::string& value_json) +void InfoLog(const std::string& key, + const std::string& key_value, + const std::string& value, + const std::string& value_json) { TRACING_INFO( kTargetName, std::make_pair(std::string("key"), key_value), std::make_pair(std::string("value"), value_json)); @@ -66,8 +66,8 @@ class SupportedDatatypesKeys final : public Scenario void run(const std::string& input) const final { // Create KVS instance with provided params. - KvsParameters params{KvsParameters::from_json(input)}; - Kvs kvs = kvs_instance(params); + KvsParameters params{KvsParameters::FromJson(input)}; + Kvs kvs = KvsInstance(params); // Try to set valid and invalid keys. // Null value is used - only key is used later on. @@ -93,22 +93,22 @@ class SupportedDatatypesKeys final : public Scenario }; for (const auto& s : keys_to_check) { - auto set_result = kvs.set_value(s, KvsValue(nullptr)); - info_log_set_result(s, set_result.has_value()); + auto set_result = kvs.SetValue(s, KvsValue(nullptr)); + InfoLogSetResult(s, set_result.has_value()); } // Log all keys stored in KVS. - auto keys_in_kvs = kvs.get_all_keys(); + auto keys_in_kvs = kvs.GetAllKeys(); if (keys_in_kvs.has_value()) { for (const auto& s : keys_in_kvs.value()) { - info_log_stored_key(s); + InfoLogStoredKey(s); } } else { - info_log("get_all_keys_error", std::string(keys_in_kvs.error().Message())); + InfoLog("get_all_keys_error", std::string(keys_in_kvs.error().Message())); throw score::result::Error(keys_in_kvs.error()); } } @@ -119,22 +119,22 @@ class SupportedDatatypesValues final : public Scenario private: KvsValue value_; - static std::string kvs_value_to_string(const KvsValue& v) + static std::string KvsValueToString(const KvsValue& v) { - switch (v.getType()) + switch (v.GetType()) { - case KvsValue::Type::i32: - return std::to_string(std::get(v.getValue())); - case KvsValue::Type::u32: - return std::to_string(std::get(v.getValue())); - case KvsValue::Type::i64: - return std::to_string(std::get(v.getValue())); - case KvsValue::Type::u64: - return std::to_string(std::get(v.getValue())); - case KvsValue::Type::f64: + case KvsValue::Type::kI32: + return std::to_string(std::get(v.GetValue())); + case KvsValue::Type::kU32: + return std::to_string(std::get(v.GetValue())); + case KvsValue::Type::kI64: + return std::to_string(std::get(v.GetValue())); + case KvsValue::Type::kU64: + return std::to_string(std::get(v.GetValue())); + case KvsValue::Type::kF64: { // Format with high precision, then remove trailing zeros and dot for minimal JSON representation. - auto val = std::get(v.getValue()); + auto val = std::get(v.GetValue()); std::ostringstream oss; oss << std::setprecision(15) << val; std::string s = oss.str(); @@ -153,37 +153,37 @@ class SupportedDatatypesValues final : public Scenario } return s; } - case KvsValue::Type::Boolean: - return std::get(v.getValue()) ? "true" : "false"; - case KvsValue::Type::String: - return "\"" + std::get(v.getValue()) + "\""; - case KvsValue::Type::Null: + case KvsValue::Type::kBoolean: + return std::get(v.GetValue()) ? "true" : "false"; + case KvsValue::Type::kString: + return "\"" + std::get(v.GetValue()) + "\""; + case KvsValue::Type::kNull: return "null"; - case KvsValue::Type::Array: + case KvsValue::Type::kArray: { - const auto& arr = std::get(v.getValue()); + const auto& arr = std::get(v.GetValue()); std::string json = "["; for (size_t i = 0; i < arr.size(); ++i) { const auto& elem = arr[i]; - json += "{\"t\":\"" + SupportedDatatypesValues(elem).name() + - "\",\"v\":" + kvs_value_to_string(elem) + "}"; + json += "{\"t\":\"" + SupportedDatatypesValues(elem).name() + "\",\"v\":" + KvsValueToString(elem) + + "}"; if (i + 1 < arr.size()) json += ","; } json += "]"; return json; } - case KvsValue::Type::Object: + case KvsValue::Type::kObject: { - const auto& obj = std::get(v.getValue()); + const auto& obj = std::get(v.GetValue()); std::string json = "{"; size_t count = 0; for (const auto& kv : obj) { const auto& elem = kv.second; json += "\"" + kv.first + "\":{\"t\":\"" + SupportedDatatypesValues(elem).name() + - "\",\"v\":" + kvs_value_to_string(elem) + "}"; + "\",\"v\":" + KvsValueToString(elem) + "}"; if (++count < obj.size()) json += ","; } @@ -202,27 +202,27 @@ class SupportedDatatypesValues final : public Scenario std::string name() const final { - switch (value_.getType()) + switch (value_.GetType()) { - case KvsValue::Type::i32: + case KvsValue::Type::kI32: return "i32"; - case KvsValue::Type::u32: + case KvsValue::Type::kU32: return "u32"; - case KvsValue::Type::i64: + case KvsValue::Type::kI64: return "i64"; - case KvsValue::Type::u64: + case KvsValue::Type::kU64: return "u64"; - case KvsValue::Type::f64: + case KvsValue::Type::kF64: return "f64"; - case KvsValue::Type::Boolean: + case KvsValue::Type::kBoolean: return "bool"; - case KvsValue::Type::String: + case KvsValue::Type::kString: return "str"; - case KvsValue::Type::Null: + case KvsValue::Type::kNull: return "null"; - case KvsValue::Type::Array: + case KvsValue::Type::kArray: return "arr"; - case KvsValue::Type::Object: + case KvsValue::Type::kObject: return "obj"; default: return "unknown"; @@ -232,66 +232,66 @@ class SupportedDatatypesValues final : public Scenario void run(const std::string& input) const final { // Create KVS instance with provided params. - KvsParameters params{KvsParameters::from_json(input)}; - Kvs kvs = kvs_instance(params); + KvsParameters params{KvsParameters::FromJson(input)}; + Kvs kvs = KvsInstance(params); // Set value. - score::cpp::ignore = kvs.set_value(name(), value_); + score::cpp::ignore = kvs.SetValue(name(), value_); // Get value. - auto kvs_value = kvs.get_value(name()); + auto kvs_value = kvs.GetValue(name()); if (kvs_value.has_value()) { // Log key and value as separate fields for Python test compatibility. - info_log("key", - name(), - "value", - std::string("{\"t\":\"" + name() + "\",\"v\":" + kvs_value_to_string(kvs_value.value()) + "}")); + InfoLog("key", + name(), + "value", + std::string("{\"t\":\"" + name() + "\",\"v\":" + KvsValueToString(kvs_value.value()) + "}")); } else { - info_log(name() + "_error", std::string(kvs_value.error().Message())); + InfoLog(name() + "_error", std::string(kvs_value.error().Message())); } } // Factory functions for each value type scenario. - static Scenario::Ptr supported_datatypes_i32() + static Scenario::Ptr SupportedDatatypesI32() { return std::make_shared(KvsValue(static_cast(-321))); } - static Scenario::Ptr supported_datatypes_u32() + static Scenario::Ptr SupportedDatatypesU32() { return std::make_shared(KvsValue(static_cast(1234))); } - static Scenario::Ptr supported_datatypes_i64() + static Scenario::Ptr SupportedDatatypesI64() { return std::make_shared(KvsValue(static_cast(-123456789))); } - static Scenario::Ptr supported_datatypes_u64() + static Scenario::Ptr SupportedDatatypesU64() { return std::make_shared(KvsValue(static_cast(123456789))); } - static Scenario::Ptr supported_datatypes_f64() + static Scenario::Ptr SupportedDatatypesF64() { return std::make_shared(KvsValue(-5432.1)); } - static Scenario::Ptr supported_datatypes_bool() + static Scenario::Ptr SupportedDatatypesBool() { return std::make_shared(KvsValue(true)); } - static Scenario::Ptr supported_datatypes_string() + static Scenario::Ptr SupportedDatatypesString() { return std::make_shared(KvsValue("example")); } - static Scenario::Ptr supported_datatypes_array() + static Scenario::Ptr SupportedDatatypesArray() { // Compose array value as in Rust. std::unordered_map obj = {{"sub-number", KvsValue(789.0)}}; @@ -304,30 +304,30 @@ class SupportedDatatypesValues final : public Scenario return std::make_shared(KvsValue(arr)); } - static Scenario::Ptr supported_datatypes_object() + static Scenario::Ptr SupportedDatatypesObject() { std::unordered_map obj = {{"sub-number", KvsValue(789.0)}}; return std::make_shared(KvsValue(obj)); } - static ScenarioGroup::Ptr value_types_group() + static ScenarioGroup::Ptr ValueTypesGroup() { - std::vector scenarios = {supported_datatypes_i32(), - supported_datatypes_u32(), - supported_datatypes_i64(), - supported_datatypes_u64(), - supported_datatypes_f64(), - supported_datatypes_bool(), - supported_datatypes_string(), - supported_datatypes_array(), - supported_datatypes_object()}; + std::vector scenarios = {SupportedDatatypesI32(), + SupportedDatatypesU32(), + SupportedDatatypesI64(), + SupportedDatatypesU64(), + SupportedDatatypesF64(), + SupportedDatatypesBool(), + SupportedDatatypesString(), + SupportedDatatypesArray(), + SupportedDatatypesObject()}; return std::make_shared("values", scenarios, std::vector{}); } }; -ScenarioGroup::Ptr supported_datatypes_group() +ScenarioGroup::Ptr SupportedDatatypesGroup() { std::vector keys = {std::make_shared()}; - std::vector groups = {SupportedDatatypesValues::value_types_group()}; + std::vector groups = {SupportedDatatypesValues::ValueTypesGroup()}; return std::make_shared("supported_datatypes", keys, groups); } diff --git a/score/kvs/tests/test_scenarios/cit/supported_datatypes.h b/score/kvs/tests/test_scenarios/cit/supported_datatypes.h index 4d18dbbeb..2f6c48a4a 100644 --- a/score/kvs/tests/test_scenarios/cit/supported_datatypes.h +++ b/score/kvs/tests/test_scenarios/cit/supported_datatypes.h @@ -15,6 +15,6 @@ #include -ScenarioGroup::Ptr supported_datatypes_group(); +ScenarioGroup::Ptr SupportedDatatypesGroup(); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_CIT_SUPPORTED_DATATYPES_H diff --git a/score/kvs/tests/test_scenarios/helpers/helpers.cpp b/score/kvs/tests/test_scenarios/helpers/helpers.cpp index b06c213d6..06119b070 100644 --- a/score/kvs/tests/test_scenarios/helpers/helpers.cpp +++ b/score/kvs/tests/test_scenarios/helpers/helpers.cpp @@ -15,9 +15,9 @@ #include -std::pair kvs_hash_paths(const std::string& working_dir, - score::kvs::InstanceId instance_id, - score::kvs::SnapshotId snapshot_id) +std::pair KvsHashPaths(const std::string& working_dir, + score::kvs::InstanceId instance_id, + score::kvs::SnapshotId snapshot_id) { std::ostringstream kvs_path; std::ostringstream hash_path; diff --git a/score/kvs/tests/test_scenarios/helpers/helpers.h b/score/kvs/tests/test_scenarios/helpers/helpers.h index 0267bf24c..7b34e3ea3 100644 --- a/score/kvs/tests/test_scenarios/helpers/helpers.h +++ b/score/kvs/tests/test_scenarios/helpers/helpers.h @@ -17,8 +17,8 @@ #include #include -std::pair kvs_hash_paths(const std::string& working_dir, - score::kvs::InstanceId instance_id, - score::kvs::SnapshotId snapshot_id); +std::pair KvsHashPaths(const std::string& working_dir, + score::kvs::InstanceId instance_id, + score::kvs::SnapshotId snapshot_id); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_HELPERS_HELPERS_H diff --git a/score/kvs/tests/test_scenarios/helpers/kvs_instance.cpp b/score/kvs/tests/test_scenarios/helpers/kvs_instance.cpp index 48f5d0e50..df845e7bf 100644 --- a/score/kvs/tests/test_scenarios/helpers/kvs_instance.cpp +++ b/score/kvs/tests/test_scenarios/helpers/kvs_instance.cpp @@ -17,31 +17,31 @@ using namespace score::kvs; -Kvs kvs_instance(const KvsParameters& params) +Kvs KvsInstance(const KvsParameters& params) { InstanceId instance_id{params.instance_id}; KvsBuilder builder{instance_id}; // Set parameters. - if (params.need_defaults.has_value()) + if (params.defaults.has_value()) { - builder = builder.need_defaults_flag(*params.need_defaults); + builder = builder.Defaults(*params.defaults); } - if (params.need_kvs.has_value()) + if (params.kvs_load.has_value()) { - builder = builder.need_kvs_flag(*params.need_kvs); + builder = builder.KvsLoad(*params.kvs_load); } if (params.dir.has_value()) { - builder = builder.dir(std::string(*params.dir)); + builder = builder.WorkingDir(std::string(*params.dir)); } if (params.snapshot_max_count.has_value()) { - builder = builder.snapshot_max_count(*params.snapshot_max_count); + builder = builder.SnapshotMaxCount(*params.snapshot_max_count); } // Build KVS instance. - auto build_result{builder.build()}; + auto build_result{builder.Build()}; if (build_result) { return std::move(*build_result); diff --git a/score/kvs/tests/test_scenarios/helpers/kvs_instance.h b/score/kvs/tests/test_scenarios/helpers/kvs_instance.h index 275e2b691..2587d8022 100644 --- a/score/kvs/tests/test_scenarios/helpers/kvs_instance.h +++ b/score/kvs/tests/test_scenarios/helpers/kvs_instance.h @@ -15,6 +15,6 @@ #include "helpers/kvs_parameters.h" -score::kvs::Kvs kvs_instance(const KvsParameters& params); +score::kvs::Kvs KvsInstance(const KvsParameters& params); #endif // SCORE_KVS_TESTS_TEST_SCENARIOS_HELPERS_KVS_INSTANCE_H diff --git a/score/kvs/tests/test_scenarios/helpers/kvs_parameters.cpp b/score/kvs/tests/test_scenarios/helpers/kvs_parameters.cpp index b0b7e1e7f..25a46251f 100644 --- a/score/kvs/tests/test_scenarios/helpers/kvs_parameters.cpp +++ b/score/kvs/tests/test_scenarios/helpers/kvs_parameters.cpp @@ -19,26 +19,26 @@ namespace { /// @brief Deserializes a load parameter: "defaults" or "kvs_load". -template || - std::is_same_v, - bool> = true> -std::optional deserialize_load_param(const score::json::Object& obj_root, const std::string& field_name) +template < + typename T, + typename std::enable_if_t || std::is_same_v, + bool> = true> +std::optional DeserializeLoadParam(const score::json::Object& obj_root, const std::string& field_name) { if (obj_root.find(field_name) != obj_root.end()) { auto value_str{obj_root.at(field_name).As().value().get()}; if (value_str == "ignored") { - return T::Ignored; + return T::kIgnored; } else if (value_str == "optional") { - return T::Optional; + return T::kOptional; } else if (value_str == "required") { - return T::Required; + return T::kRequired; } else { @@ -51,7 +51,7 @@ std::optional deserialize_load_param(const score::json::Object& obj_root, con } // namespace -KvsParameters KvsParameters::from_json(const std::string& json_str) +KvsParameters KvsParameters::FromJson(const std::string& json_str) { // Load and parse provided JSON string. JsonParser parser; @@ -61,10 +61,10 @@ KvsParameters KvsParameters::from_json(const std::string& json_str) throw score::result::Error(any_res.error()); } - return KvsParameters::from_object(any_res.value().As().value().get()); + return KvsParameters::FromValue(any_res.value().As().value().get()); } -KvsParameters KvsParameters::from_object(const Object& object) +KvsParameters KvsParameters::FromValue(const Object& object) { // Take "kvs_parameters" field containing object. const auto& map_root{object.at("kvs_parameters")}; @@ -73,10 +73,10 @@ KvsParameters KvsParameters::from_object(const Object& object) KvsParameters params{.instance_id = obj_root.at("instance_id").As().value()}; // Deserialize "defaults". - params.need_defaults = deserialize_load_param(obj_root, "defaults"); + params.defaults = DeserializeLoadParam(obj_root, "defaults"); // Deserialize "kvs_load". - params.need_kvs = deserialize_load_param(obj_root, "kvs_load"); + params.kvs_load = DeserializeLoadParam(obj_root, "kvs_load"); // Deserialize "dir". if (obj_root.find("dir") != obj_root.end()) diff --git a/score/kvs/tests/test_scenarios/helpers/kvs_parameters.h b/score/kvs/tests/test_scenarios/helpers/kvs_parameters.h index 9139a8ad3..1599fb8fa 100644 --- a/score/kvs/tests/test_scenarios/helpers/kvs_parameters.h +++ b/score/kvs/tests/test_scenarios/helpers/kvs_parameters.h @@ -24,16 +24,16 @@ struct KvsParameters /// @brief Parses `KvsParameters` from a JSON string. /// /// JSON is expected to contain `kvs_parameters` field. - static KvsParameters from_json(const std::string& json_str); + static KvsParameters FromJson(const std::string& json_str); /// @brief Parses `KvsParameters` from an `Object`. /// /// `Object` is expected to contain `kvs_parameters` field. - static KvsParameters from_object(const score::json::Object& object); + static KvsParameters FromValue(const score::json::Object& object); score::kvs::InstanceId instance_id; - std::optional need_defaults; - std::optional need_kvs; + std::optional defaults; + std::optional kvs_load; std::optional dir; std::optional snapshot_max_count; }; diff --git a/score/kvs/tests/test_scenarios/main.cpp b/score/kvs/tests/test_scenarios/main.cpp index 868c22123..37558251c 100644 --- a/score/kvs/tests/test_scenarios/main.cpp +++ b/score/kvs/tests/test_scenarios/main.cpp @@ -33,7 +33,7 @@ int main(int argc, char** argv) ScenarioGroup::Ptr basic_group{new ScenarioGroupImpl{"basic", {basic_scenario}, {}}}; // CIT group. - ScenarioGroup::Ptr cit_group{cit_scenario_group()}; + ScenarioGroup::Ptr cit_group{CitScenarioGroup()}; // Root group. ScenarioGroup::Ptr root_group{new ScenarioGroupImpl{"root", {}, {basic_group, cit_group}}}; diff --git a/score/kvs/tests/test_scenarios/test_basic.cpp b/score/kvs/tests/test_scenarios/test_basic.cpp index 72318a639..07f32c654 100644 --- a/score/kvs/tests/test_scenarios/test_basic.cpp +++ b/score/kvs/tests/test_scenarios/test_basic.cpp @@ -39,44 +39,44 @@ void BasicScenario::run(const std::string& input) const // Print and parse parameters. std::cerr << input << std::endl; - auto params{KvsParameters::from_json(input)}; + auto params{KvsParameters::FromJson(input)}; // Set builder parameters. InstanceId instance_id{params.instance_id}; KvsBuilder builder{instance_id}; - if (params.need_defaults.has_value()) + if (params.defaults.has_value()) { - builder = builder.need_defaults_flag(*params.need_defaults); + builder = builder.Defaults(*params.defaults); } - if (params.need_kvs.has_value()) + if (params.kvs_load.has_value()) { - builder = builder.need_kvs_flag(*params.need_kvs); + builder = builder.KvsLoad(*params.kvs_load); } // Create KVS. - Kvs kvs{*builder.build()}; + Kvs kvs{*builder.Build()}; // Simple set/get. std::string key{"example_key"}; std::string value{"example_value"}; - auto set_value_result{kvs.set_value(key, KvsValue{value})}; + auto set_value_result{kvs.SetValue(key, KvsValue{value})}; if (!set_value_result) { throw std::runtime_error("Failed to set value"); } - auto get_value_result{kvs.get_value(key)}; + auto get_value_result{kvs.GetValue(key)}; if (!get_value_result) { throw std::runtime_error{"Failed to get value"}; } auto stored_kvs_value{get_value_result.value()}; - if (stored_kvs_value.getType() != KvsValue::Type::String) + if (stored_kvs_value.GetType() != KvsValue::Type::kString) { throw std::runtime_error{"Invalid value type"}; } - auto stored_value{std::get(stored_kvs_value.getValue())}; + auto stored_value{std::get(stored_kvs_value.GetValue())}; if (stored_value != value) { throw std::runtime_error("Value mismatch");