helpers.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/eventServiceIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/test/fakeComponentMetrics.hpp>
#include <rtctk/componentFramework/test/fakeOldbIf.hpp>
#include <rtctk/componentFramework/test/fakeRuntimeRepoIf.hpp>
 
#include <memory>
#include <mutex>
 
using ::testing::_;           // NOLINT(google-global-names-in-headers)
using ::testing::InSequence;  // NOLINT(google-global-names-in-headers)
using ::testing::NiceMock;    // NOLINT(google-global-names-in-headers)
using ::testing::Return;      // NOLINT(google-global-names-in-headers)
using ::testing::Sequence;    // NOLINT(google-global-names-in-headers)
 
using namespace rtctk::componentFramework;        // NOLINT(google-global-names-in-headers)
using namespace rtctk::componentFramework::test;  // NOLINT(google-global-names-in-headers)
 
extern void* rec_ptr;
 
class MockEventPublisher;
class MockEventSubscriber;
class MockEventService;
 
class MockEventPublisher : public EventPublisherIf {
public:
    friend MockEventService;
 
    void Publish(const JsonPayload& sample) override {
    }
 
private:
    explicit MockEventPublisher(const std::string& topic) {
    }
};
 
class MockEventSubscriber : public EventSubscriberIf {
public:
    friend MockEventService;
 
    void Subscribe(std::function<void(const JsonPayload&)> cb) override {
        auto lock = std::scoped_lock(callback_lock);
        callback = cb;
        SubscribeMock(cb);
    }
    MOCK_METHOD(void, SubscribeMock, (std::function<void(const JsonPayload&)>), ());
    MOCK_METHOD(void, Unsubscribe, (), (override));
 
    std::function<void(const JsonPayload&)> GetCallback() {
        auto lock = std::scoped_lock(callback_lock);
        auto copy = callback;
        return copy;
    };
 
private:
    std::function<void(const JsonPayload&)> callback;
    std::mutex callback_lock;
 
    explicit MockEventSubscriber(const std::string& topic) {
    }
};
 
class MockEventService : public EventServiceIf {
public:
    MockEventService() = default;
 
    std::unique_ptr<EventPublisherIf> MakePublisher(const std::string& topic) override {
        pub[topic] = new MockEventPublisher(topic);
        return std::unique_ptr<MockEventPublisher>(pub.at(topic));
    }
 
    std::unique_ptr<EventSubscriberIf> MakeSubscriber(const std::string& topic) override {
        sub[topic] = new MockEventSubscriber(topic);
        return std::unique_ptr<MockEventSubscriber>(sub.at(topic));
    }
 
    std::map<std::string, MockEventPublisher*> pub;
    std::map<std::string, MockEventSubscriber*> sub;
};
 
struct FakeServices {
    FakeServices() {
        services.Add<RuntimeRepoIf>(std::make_shared<test::FakeRuntimeRepoIf>());
        services.Add<OldbIf>(std::make_shared<test::FakeOldbIf>());
        services.Add<ComponentMetricsIf>(std::make_shared<FakeComponentMetrics>());
        // cppcheck-suppress useInitializationList
        es = std::make_shared<MockEventService>();
        services.Add<EventServiceIf>(es);
    }
 
    ServiceContainer& operator*() {
        return services;
    }
 
    MockEventService& Es() {
        return *es;
    }
 
    ServiceContainer services;
    std::shared_ptr<MockEventService> es;
};
 
ACTION(Throw) {
    CII_THROW(RtctkException, "Some Exception");
}