mock.h

Go to the documentation of this file.

#pragma once
 
#include <gmock/gmock.h>
 
#include <cstdint>
#include <filesystem>
#include <random>
#include <string>
#include <string_view>
#include <system_error>
#include <unordered_map>
 
#include "cppfig/interface.h"
#include "cppfig/setting.h"
#include "cppfig/traits.h"
#include "cppfig/value.h"
 
namespace cppfig::testing {
 
template <typename Schema>
class MockConfiguration {
public:
    using schema_type = Schema;
 
    MockConfiguration() { BuildDefaults(); }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    [[nodiscard]] auto Get() const -> typename S::value_type
    {
        using value_type = typename S::value_type;
        std::string key(S::path);
 
        auto iter = values_.find(key);
        if (iter != values_.end()) {
            auto parsed = ConfigTraits<value_type>::Deserialize(iter->second);
            if (parsed.has_value()) {
                return *parsed;
            }
        }
 
        // Return default
        return S::default_value();
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    void SetValue(typename S::value_type value)
    {
        using value_type = typename S::value_type;
        std::string key(S::path);
        values_[key] = ConfigTraits<value_type>::Serialize(value);
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    auto Set(typename S::value_type value) -> Status
    {
        auto validator = GetSettingValidator<S>();
        auto validation = validator(value);
        if (!validation) {
            return InvalidArgumentError(validation.error_message);
        }
 
        SetValue<S>(std::move(value));
        return OkStatus();
    }
 
    [[nodiscard]] auto Load() -> Status { return OkStatus(); }
 
    [[nodiscard]] auto Save() const -> Status { return OkStatus(); }
 
    void Reset()
    {
        values_.clear();
        BuildDefaults();
    }
 
    void SetRawValue(std::string_view path, Value value) { values_[std::string(path)] = std::move(value); }
 
    void ClearValue(std::string_view path) { values_.erase(std::string(path)); }
 
private:
    void BuildDefaults()
    {
        Schema::ForEachSetting([this]<typename S>() {
            using value_type = typename S::value_type;
            std::string key(S::path);
            values_[key] = ConfigTraits<value_type>::Serialize(S::default_value());
        });
    }
 
    std::unordered_map<std::string, Value> values_;
};
 
// LCOV_EXCL_START — GMock macro internals generate uninstrumented stubs
class MockVirtualConfigurationProvider : public IConfigurationProviderVirtual {
public:
    MOCK_METHOD(Status, Load, (), (override));
    MOCK_METHOD(Status, Save, (), (const, override));
    MOCK_METHOD(std::string_view, GetFilePath, (), (const, override));
    MOCK_METHOD(Status, ValidateAll, (), (const, override));
    MOCK_METHOD(std::string, GetDiffString, (), (const, override));
};
 
class ConfigurationTestFixture {
public:
    [[nodiscard]] static auto CreateTempFilePath(std::string_view prefix = "test_config") -> std::string
    {
        static std::mt19937_64 generator { std::random_device {}() };
        std::uniform_int_distribution<std::uint64_t> distribution;
 
        const auto path = std::filesystem::temp_directory_path()
            / (std::string(prefix) + "_" + std::to_string(distribution(generator)) + ".conf");
        return path.string();
    }
 
    static void RemoveFile(const std::string& path)
    {
        std::error_code error_code;
        std::filesystem::remove(path, error_code);
    }
};
// LCOV_EXCL_STOP
 
}  // namespace cppfig::testing