storage_mock.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/dynamic_config/storage_mock.hpp
/// @brief @copybrief dynamic_config::StorageMock
 
#include <initializer_list>
#include <memory>
#include <vector>
 
#include <userver/dynamic_config/snapshot.hpp>
#include <userver/dynamic_config/source.hpp>
#include <userver/dynamic_config/value.hpp>
#include <userver/formats/json/value.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace dynamic_config {
namespace impl {
 
template <typename T>
using IsJson = std::enable_if_t<std::is_same_v<T, formats::json::Value>>;
 
}  // namespace impl
 
/// A type-erased config key-value pair
class KeyValue final {
 public:
  /// Uses the provided value directly. It can also be constructed in-place:
  /// @code
  /// {kMyConfig, {"foo", 42}}
  /// @endcode
  ///
  /// When passed a formats::json::Value, parses the value from it:
  /// @code
  /// {kMyConfig, formats::json::FromString(R"({"foo": "what", "bar": 42})")}
  /// @endcode
  template <typename VariableType, typename Value = VariableType>
  KeyValue(const Key<VariableType>& key, Value&& value)
      : id_(impl::ConfigIdGetter::Get(key)),
        value_(Convert<VariableType>(std::forward<Value>(value))) {}
 
  /// For internal use only
  impl::ConfigId GetId() const { return id_; }
 
  /// For internal use only
  std::any GetValue() const { return value_; }
 
 private:
  template <typename VariableType, typename Value>
  static VariableType Convert(Value&& value) {
    if constexpr (std::is_same_v<std::decay_t<Value>, formats::json::Value>) {
      return value.template As<VariableType>();
    } else {
      return static_cast<VariableType>(std::forward<Value>(value));
    }
  }
 
  impl::ConfigId id_;
  std::any value_;
};
 
/// @brief Backing storage for `dynamic_config::Source` in tests and benchmarks
/// @warning Make sure that `StorageMock` outlives all the acquired pointers!
/// @snippet core/src/dynamic_config/config_test.cpp  Sample StorageMock usage
/// @snippet core/src/dynamic_config/config_test.cpp  StorageMock from JSON
/// @see dynamic_config::GetDefaultSource
/// @see dynamic_config::MakeDefaultStorage
class StorageMock final {
 public:
  /// Create an empty `StorageMock`
  StorageMock();
 
  /// Only store `config_variables` in the `Config`.
  /// Use as: `StorageMock{{kVariableKey1, value1}, {kVariableKey2, value2}}`
  StorageMock(std::initializer_list<KeyValue> config_variables);
 
  /// Only store `config_variables` in the `Config`
  explicit StorageMock(const std::vector<KeyValue>& config_variables);
 
  /// @brief Store `overrides` in the `Config`, then parse all the remaining
  /// variables from `defaults`
  /// @see dynamic_config::MakeDefaultStorage
  StorageMock(const DocsMap& defaults, const std::vector<KeyValue>& overrides);
 
  StorageMock(StorageMock&&) noexcept;
  StorageMock& operator=(StorageMock&&) noexcept;
  ~StorageMock();
 
  /// Update some config variables
  void Extend(const std::vector<KeyValue>& overrides);
 
  Source GetSource() const&;
  Snapshot GetSnapshot() const&;
 
  // Store the StorageMock in a variable before using
  Snapshot GetSource() && = delete;
  Snapshot GetSnapshot() && = delete;
 
 private:
  std::unique_ptr<impl::StorageData> storage_;
};
 
}  // namespace dynamic_config
 
USERVER_NAMESPACE_END