ServiceRegistry.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac

    This file is part of Leosac.

    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include "tools/service/ServiceRegistry.hpp"
#include "gtest/gtest.h"

using namespace Leosac;

namespace Leosac
{
namespace Test
{

struct DummyServiceInterface
{
    virtual bool is_even(int number) const = 0;
};

struct DummyServiceInterface2
{
};

struct DummyServiceImpl : public DummyServiceInterface
{
    virtual bool is_even(int number) const override
    {
        return (number % 2) == 0;
    }
};

TEST(TestRegistry, register_get_service)
{
    ServiceRegistry srv_registry;

    // No service registered for this interface.
    // Will return -1.
    ASSERT_EQ(-1, srv_registry.use_count<DummyServiceInterface>());
    // No service yet, will return null.
    ASSERT_EQ(nullptr, srv_registry.get_service<DummyServiceInterface>());


    bool event_listener_invoked = false;
    srv_registry.register_event_listener([&](const service_event::Event &ev) {
        event_listener_invoked = true;
        ASSERT_EQ(service_event::EventType::REGISTERED, ev.type());
        ASSERT_NO_THROW(dynamic_cast<const service_event::ServiceRegistered &>(ev));
    });

    auto handle =
        srv_registry.register_service<DummyServiceInterface>(new DummyServiceImpl());
    ASSERT_TRUE(event_listener_invoked);

    ASSERT_EQ(0, srv_registry.use_count<DummyServiceInterface>());
    {
        std::shared_ptr<DummyServiceInterface> srv =
            srv_registry.get_service<DummyServiceInterface>();
        ASSERT_EQ(1, srv_registry.use_count<DummyServiceInterface>());
        ASSERT_TRUE(srv->is_even(0));
        ASSERT_FALSE(srv->is_even(1));
    }
    ASSERT_EQ(0, srv_registry.use_count<DummyServiceInterface>());
}

TEST(TestRegistry, unregister_simple)
{
    ServiceRegistry srv_registry;

    bool event_listener_invoked = false;

    auto handle =
        srv_registry.register_service<DummyServiceInterface>(new DummyServiceImpl());
    ASSERT_NE(nullptr, srv_registry.get_service<DummyServiceInterface>());
    ASSERT_FALSE(event_listener_invoked);

    srv_registry.register_event_listener([&](const service_event::Event &ev) {
        event_listener_invoked = true;
        ASSERT_EQ(service_event::EventType::UNREGISTERED, ev.type());
        ASSERT_NO_THROW(
            dynamic_cast<const service_event::ServiceUnregistered &>(ev));
    });

    ASSERT_TRUE(srv_registry.unregister_service(handle));
    ASSERT_TRUE(event_listener_invoked);
    ASSERT_EQ(nullptr, srv_registry.get_service<DummyServiceInterface>());
}

TEST(TestRegistry, unregister_while_used)
{
    ServiceRegistry srv_registry;

    auto handle =
        srv_registry.register_service<DummyServiceInterface>(new DummyServiceImpl());
    ASSERT_NE(nullptr, srv_registry.get_service<DummyServiceInterface>());

    {
        auto srv = srv_registry.get_service<DummyServiceInterface>();
        ASSERT_FALSE(srv_registry.unregister_service(handle));
    }
    ASSERT_TRUE(srv_registry.unregister_service(handle));
}

TEST(TestRegistry, unregister_no_param)
{
    ServiceRegistry srv_registry;

    auto handle =
        srv_registry.register_service<DummyServiceInterface>(new DummyServiceImpl());
    ASSERT_FALSE(srv_registry.unregister_service<DummyServiceInterface2>());
    ASSERT_TRUE(srv_registry.unregister_service<DummyServiceInterface>());
}
}
}