managerMock.hpp

Go to the documentation of this file.

#ifndef DAQ_OCM_SERVER_MOCK_MANAGER_MOCK_HPP_
#define DAQ_OCM_SERVER_MOCK_MANAGER_MOCK_HPP_
#include <daq/manager.hpp>
#include <daq/status.hpp>
#include <daq/daqController.hpp>
 
#include <gmock/gmock.h>
 
struct ManagerMock : daq::Manager {
    MOCK_CONST_METHOD2(HaveDaq, bool(std::string_view, std::string_view));
    MOCK_CONST_METHOD1(MakeDaqId, std::string(std::chrono::system_clock::time_point*));
    MOCK_CONST_METHOD1(GetStatus, daq::Status(std::string_view));
    MOCK_METHOD1(StartDaqAsync, boost::future<daq::State>(daq::DaqContext));
    MOCK_METHOD2(StopDaqAsync, boost::future<daq::Status>(std::string_view, daq::ErrorPolicy));
    MOCK_METHOD2(AbortDaqAsync, boost::future<daq::Status>(std::string_view, daq::ErrorPolicy));
    MOCK_METHOD3(AwaitDaqStateAsync,
                 boost::future<daq::Result<daq::Status>>(std::string_view,
                                                         daq::State,
                                                         std::chrono::milliseconds));
 
    MOCK_METHOD2(UpdateKeywords, void(std::string_view, daq::fits::KeywordVector const&));
    MOCK_METHOD0(RestoreFromWorkspace, void());
    MOCK_METHOD0(GetStatusSignal, daq::StatusSignal&());
    MOCK_METHOD0(GetDaqControllers, std::vector<std::shared_ptr<daq::DaqController const>>());
};
 
struct DaqControllerFake : daq::DaqController {
    DaqControllerFake(std::shared_ptr<daq::ObservableStatus> status_arg)
        : status(std::move(status_arg)), ctx() {
        ctx.id = status->GetId();
    }
    boost::future<daq::State> StartAsync() override {
        throw std::runtime_error("not implemented");
    }
    boost::future<daq::Status> StopAsync(daq::ErrorPolicy policy) override {
        throw std::runtime_error("not implemented");
    }
    boost::future<daq::Status> AbortAsync(daq::ErrorPolicy policy) override {
        throw std::runtime_error("not implemented");
    }
    boost::future<daq::State> ScheduleMergeAsync() override {
        throw std::runtime_error("not implemented");
    }
    void UpdateKeywords(daq::fits::KeywordVector const& keywords) override {
        throw std::runtime_error("not implemented");
    }
    boost::future<daq::State>
    AwaitAsync(std::vector<std::string> sources, std::chrono::milliseconds timeout) override {
        throw std::runtime_error("not implemented");
    }
    daq::State GetState() const DAQ_NOEXCEPT override {
        return status->GetState();
    }
    std::shared_ptr<daq::ObservableStatus> GetStatus() DAQ_NOEXCEPT override {
        return status;
    }
    std::shared_ptr<daq::ObservableStatus const> GetStatus() const DAQ_NOEXCEPT override {
        return status;
    }
    std::shared_ptr<daq::ObservableEventLog> GetEventLog() DAQ_NOEXCEPT override {
        throw std::runtime_error("not implemented");
    }
    std::string const& GetId() const DAQ_NOEXCEPT override {
        return status->GetId();
    }
    bool GetErrorFlag() const DAQ_NOEXCEPT override {
        return status->GetError();
    }
    daq::DaqContext const& GetContext() const DAQ_NOEXCEPT override {
        return ctx;
    }
 
    boost::signals2::connection
    ConnectContext(ContextSignal::slot_type const& slot) override {
        return signal.connect(slot);
    }
 
    ContextSignal signal;
 
    std::shared_ptr<daq::ObservableStatus> status;
    daq::DaqContext ctx;
};
 
#endif // #ifndef DAQ_OCM_SERVER_MOCK_MANAGER_MOCK_HPP_