syncspirit/tests/diff-builder.h

// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: 2019-2026 Ivan Baidakou

#pragma once

#include <filesystem>
#include <boost/outcome.hpp>
#include <rotor/supervisor.h>

#include "test-utils.h"
#include "syncspirit-test-export.h"
#include "model/device.h"
#include "model/ignored_device.h"
#include "model/pending_device.h"
#include "model/file_info.h"
#include "model/diff/apply_controller.h"
#include "model/diff/cluster_diff.h"
#include "model/diff/block_diff.h"
#include "model/diff/modify/block_transaction.h"
#include "model/misc/sequencer.h"

namespace syncspirit::test {

namespace r = rotor;
namespace bfs = std::filesystem;
namespace outcome = boost::outcome_v2;

struct diff_builder_t;

struct SYNCSPIRIT_TEST_API cluster_configurer_t {
    cluster_configurer_t(diff_builder_t &builder, utils::bytes_view_t peer_sha256,
                         const bfs::path default_location = {}) noexcept;
    cluster_configurer_t &&add(utils::bytes_view_t sha256, std::string_view folder_id, uint64_t index,
                               int64_t max_sequence, std::string_view url = {}) noexcept;
    cluster_configurer_t &&add_named(utils::bytes_view_t sha256, std::string_view folder_id, uint64_t index,
                                     int64_t max_sequence, std::string_view folder_name) noexcept;
    diff_builder_t &finish() noexcept;
    std::error_code fail() noexcept;

  private:
    proto::ClusterConfig cc;
    diff_builder_t &builder;
    utils::bytes_view_t peer_sha256;
    bfs::path default_location;
};

struct SYNCSPIRIT_TEST_API index_maker_t {
    index_maker_t(diff_builder_t &builder, utils::bytes_view_t peer_sha256, std::string_view folder_id) noexcept;
    index_maker_t &&add(const proto::FileInfo &, const model::device_ptr_t &peer, bool add_version = true) noexcept;
    diff_builder_t &finish() noexcept;
    std::error_code fail() noexcept;

  private:
    proto::Index index;
    diff_builder_t &builder;
    utils::bytes_view_t peer_sha256;
};

struct SYNCSPIRIT_TEST_API diff_builder_t : protected model::diff::apply_controller_t {
    using blocks_t = std::vector<proto::BlockInfo>;

    diff_builder_t(model::cluster_t &, r::address_ptr_t receiver = {}, model::sequencer_ptr_t sequencer = {}) noexcept;
    ~diff_builder_t();
    cluster_configurer_t configure_cluster(utils::bytes_view_t sha256, const bfs::path &default_location = {}) noexcept;
    diff_builder_t &apply(r::supervisor_t &sup, const void *custom = {}) noexcept;
    void send(r::supervisor_t &sup, const void *custom = {}) noexcept;
    outcome::result<void> apply(void *custom = {}) noexcept;
    model::diff::cluster_diff_ptr_t extract() noexcept;
    diff_builder_t &then() noexcept;
    index_maker_t make_index(utils::bytes_view_t sha256, std::string_view folder_id) noexcept;

    diff_builder_t &upsert_folder(std::string_view id, const bfs::path &path, std::string_view label = "",
                                  std::uint64_t index_id = 0, bool watched = false) noexcept;
    diff_builder_t &upsert_folder(const db::Folder &data, std::uint64_t index_id = 0) noexcept;
    diff_builder_t &upsert_folder_info(model::folder_info_t &prev, std::uint64_t new_index_id) noexcept;
    diff_builder_t &update_peer(const model::device_id_t &device, std::string_view name = "",
                                std::string_view cert_name = "", bool auto_accept = false) noexcept;
    diff_builder_t &share_folder(utils::bytes_view_t sha256, std::string_view folder_id,
                                 utils::bytes_view_t introducer_sha256 = {}) noexcept;
    diff_builder_t &unshare_folder(model::folder_info_t &fi) noexcept;
    diff_builder_t &remote_copy(const model::file_info_t &source, const model::folder_info_t &source_fi) noexcept;
    diff_builder_t &advance(const model::file_info_t &source, const model::folder_info_t &source_fi) noexcept;
    virtual diff_builder_t &local_update(std::string_view folder_id, const proto::FileInfo &file_) noexcept;
    diff_builder_t &ack_block(const model::diff::modify::block_transaction_t &) noexcept;
    diff_builder_t &remove_folder(const model::folder_t &folder) noexcept;
    diff_builder_t &remove_peer(const model::device_t &peer) noexcept;
    diff_builder_t &update_state(const model::device_t &peer, const r::address_ptr_t &peer_addr,
                                 const model::device_state_t &state) noexcept;
    diff_builder_t &update_contact(const model::device_id_t &device, const utils::uri_container_t &uris) noexcept;
    diff_builder_t &add_ignored_device(const model::device_id_t &device, db::SomeDevice db_device) noexcept;
    diff_builder_t &add_unknown_device(const model::device_id_t &device, db::SomeDevice db_device) noexcept;
    diff_builder_t &remove_ignored_device(const model::ignored_device_t &device) noexcept;
    diff_builder_t &remove_unknown_device(const model::pending_device_t &device) noexcept;
    diff_builder_t &scan_start(std::string_view id, std::string_view sub_dir = {}, const r::pt::ptime & = {}) noexcept;
    diff_builder_t &scan_finish(std::string_view id, const r::pt::ptime & = {}) noexcept;
    diff_builder_t &scan_request(std::string_view id, std::string_view sub_dir = {}) noexcept;
    diff_builder_t &synchronization_start(std::string_view id) noexcept;
    diff_builder_t &synchronization_finish(std::string_view id) noexcept;
    diff_builder_t &mark_reacheable(model::file_info_ptr_t peer_file, const model::folder_info_t &peer_fi,
                                    bool value) noexcept;
    diff_builder_t &suspend(const model::folder_t &folder, bool value = true) noexcept;
    diff_builder_t &interrupt() noexcept;

    model::sequencer_t &get_sequencer() noexcept;

    diff_builder_t &assign(model::diff::cluster_diff_t *) noexcept;

  protected:
    model::sequencer_ptr_t sequencer;
    apply_controller_ptr_t controller;
    model::diff::cluster_diff_ptr_t cluster_diff;
    r::address_ptr_t receiver;

    friend struct cluster_configurer_t;
    friend struct index_maker_t;
};

} // namespace syncspirit::test