Integration tests for Configuration and SwitchManager

Change-Id: Ic52cb42766bec9b2cbc12cc83aab74c12b0e7782

diff --git a/src/AccessoriesSwitchProvider.cpp b/src/AccessoriesSwitchProvider.cpp
index 0d8bb15..64c4540 100644 (file)
--- a/src/AccessoriesSwitchProvider.cpp
+++ b/src/AccessoriesSwitchProvider.cpp
@@ -1,5 +1,7 @@
 #include "AccessoriesSwitchProvider.hpp"
 
+#include <Ecore.h>
+
 AccessoriesSwitchProvider::AccessoriesSwitchProvider()
        : SwitchProvider("AccessoriesSwitchProvider"), keys(
 {"XF86AddFavorite",
@@ -676,20 +678,20 @@ AccessoriesSwitchProvider::AccessoriesSwitchProvider()
 })
 {
        for (auto &key : keys)
-               switches.emplace_back(std::make_shared<Switch>(key, shared_from_this()));
+               switches.emplace_back(std::make_shared<Switch>(key, switchProviderId));
 
        ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, onEcoreEventKeyDownCb, this);
 }
 
-SwitchProvider::SwitchCollection AccessoriesSwitchProvider::findAllSwitches()
+SwitchProvider::SwitchCollection AccessoriesSwitchProvider::findAllSwitches() const
 {
        return switches;
 }
 
-std::shared_ptr<Switch> AccessoriesSwitchProvider::findSwitchById(const std::string &id)
+std::shared_ptr<Switch> AccessoriesSwitchProvider::findSwitchById(const std::string &switchId) const
 {
        for (auto &sw : switches) {
-               if (sw->getId()->getGlobalId() == id)
+               if (sw->getId()->getGlobalId() == switchId)
                        return sw;
        }
 
@@ -699,10 +701,11 @@ std::shared_ptr<Switch> AccessoriesSwitchProvider::findSwitchById(const std::str
 Eina_Bool AccessoriesSwitchProvider::onEcoreEventKeyDownCb(void *data, int type, void *ev)
 {
        auto event = static_cast<Ecore_Event_Key *>(ev);
-       std::string id(event->key);
+       std::string keyId(event->key);
 
        auto accessoriesSwitchProvider = reinterpret_cast<AccessoriesSwitchProvider*>(data);
-       auto sw = accessoriesSwitchProvider->findSwitchById(id);
+       auto switchId = SwitchId(keyId, accessoriesSwitchProvider->getId());
+       auto sw = accessoriesSwitchProvider->findSwitchById(switchId.getGlobalId());
 
        if (sw)
                accessoriesSwitchProvider->notify(sw);

diff --git a/src/AccessoriesSwitchProvider.hpp b/src/AccessoriesSwitchProvider.hpp
index ecacf4b..2dd0011 100644 (file)
--- a/src/AccessoriesSwitchProvider.hpp
+++ b/src/AccessoriesSwitchProvider.hpp
@@ -9,13 +9,13 @@
 #include <string>
 #include <memory>
 
-class AccessoriesSwitchProvider : public SwitchProvider, std::enable_shared_from_this<AccessoriesSwitchProvider>
+class AccessoriesSwitchProvider : public SwitchProvider
 {
 public:
        AccessoriesSwitchProvider();
 
-       SwitchCollection findAllSwitches() override;
-       std::shared_ptr<Switch> findSwitchById(const std::string &id) override;
+       SwitchCollection findAllSwitches() const override;
+       std::shared_ptr<Switch> findSwitchById(const std::string &switchId) const override;
 
 private:
        static Eina_Bool onEcoreEventKeyDownCb(void *data, int type, void *ev);

diff --git a/src/CompositeSwitchProvider.cpp b/src/CompositeSwitchProvider.cpp
index d7a686d..91c5e86 100644 (file)
--- a/src/CompositeSwitchProvider.cpp
+++ b/src/CompositeSwitchProvider.cpp
@@ -4,7 +4,7 @@ CompositeSwitchProvider::CompositeSwitchProvider()
        : SwitchProvider("CompositeSwitchProvider")
 {}
 
-CompositeSwitchProvider::SwitchCollection CompositeSwitchProvider::findAllSwitches()
+CompositeSwitchProvider::SwitchCollection CompositeSwitchProvider::findAllSwitches() const
 {
        SwitchCollection result;
 
@@ -16,7 +16,7 @@ CompositeSwitchProvider::SwitchCollection CompositeSwitchProvider::findAllSwitch
        return result;
 }
 
-std::shared_ptr<Switch> CompositeSwitchProvider::findSwitchById(const std::string &id)
+std::shared_ptr<Switch> CompositeSwitchProvider::findSwitchById(const std::string &id) const
 {
        for (auto &provider : providers) {
                auto sw = provider->findSwitchById(id);

diff --git a/src/CompositeSwitchProvider.hpp b/src/CompositeSwitchProvider.hpp
index 540a7b6..9f96903 100644 (file)
--- a/src/CompositeSwitchProvider.hpp
+++ b/src/CompositeSwitchProvider.hpp
@@ -10,8 +10,8 @@ class CompositeSwitchProvider : public SwitchProvider
 public:
        CompositeSwitchProvider();
 
-       SwitchCollection findAllSwitches() override;
-       std::shared_ptr<Switch> findSwitchById(const std::string &id) override;
+       SwitchCollection findAllSwitches() const override;
+       std::shared_ptr<Switch> findSwitchById(const std::string &id) const override;
        void add(std::shared_ptr<SwitchProvider> provider);
        std::vector<std::shared_ptr<SwitchProvider>> getProviders();
 

diff --git a/src/Condition.hpp b/src/Condition.hpp
index d777f71..f917ddd 100644 (file)
--- a/src/Condition.hpp
+++ b/src/Condition.hpp
@@ -1,11 +1,14 @@
-#ifndef CONDITION_HPP_
-#define CONDITION_HPP_
+#ifndef CONDITION_HPP
+#define CONDITION_HPP
+
+#include <memory>
 
 template<typename T>
 class Condition {
 public:
-       virtual ~Condition(){};
+       virtual ~Condition() = default;
        virtual bool matching(const T *item) const = 0;
+       virtual std::shared_ptr<T> getItem() const = 0;
 };
 
 #endif

diff --git a/src/ConditionAll.hpp b/src/ConditionAll.hpp
index 7dde971..8eb5886 100644 (file)
--- a/src/ConditionAll.hpp
+++ b/src/ConditionAll.hpp
@@ -10,6 +10,10 @@ public:
        bool matching(const T *item) const override {
                return true;
        }
+       
+       std::shared_ptr<T> getItem() const override {
+               return nullptr;
+       }
 };
 
 #endif

diff --git a/src/ConditionAny.hpp b/src/ConditionAny.hpp
deleted file mode 100644 (file)
index 43406bc..0000000
--- a/src/ConditionAny.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef CONDITION_ANY_HPP
-#define CONDITION_ANY_HPP
-
-#include "Condition.hpp"
-
-template<typename T>
-class ConditionAny : public Condition<T>
-{
-public:
-       ConditionAny(std::vector<std::shared_ptr<T>> items)
-               : items(std::move(items))
-       {}
-
-       bool matching(const T* item) const override {
-               for (auto &it : items)
-                       if (*item == *it)
-                               return true;
-               return false;
-       }
-
-private:
-       std::vector<std::shared_ptr<T>> items;
-};
-
-#endif

diff --git a/src/ConditionEqual.hpp b/src/ConditionEqual.hpp
index 54e62b2..f3c9d9a 100644 (file)
--- a/src/ConditionEqual.hpp
+++ b/src/ConditionEqual.hpp
@@ -7,16 +7,20 @@ template<typename T>
 class ConditionEqual : public Condition<T>
 {
 public:
-       ConditionEqual(std::shared_ptr<T> item)
-               :item(std::move(item))
+       ConditionEqual(const std::shared_ptr<T> &item)
+               :item(item)
        {}
 
        bool matching(const T *item) const override {
                return *item == *(this->item);
        }
 
+       std::shared_ptr<T> getItem() const override {
+               return item;
+       }
+
 private:
-       std::shared_ptr<T> item;
+       const std::shared_ptr<T> item;
 };
 
 #endif

diff --git a/src/Configuration.hpp b/src/Configuration.hpp
index 1b2a3fa..f989728 100644 (file)
--- a/src/Configuration.hpp
+++ b/src/Configuration.hpp
@@ -1,5 +1,5 @@
-#ifndef CONFIGURATION_HPP_
-#define CONFIGURATION_HPP_
+#ifndef CONFIGURATION_HPP
+#define CONFIGURATION_HPP
 
 #include "Subject.hpp"
 #include "SwitchConfigurationItem.hpp"

diff --git a/src/Observer.hpp b/src/Observer.hpp
index 9e2532f..082db7d 100644 (file)
--- a/src/Observer.hpp
+++ b/src/Observer.hpp
@@ -1,16 +1,14 @@
-#ifndef OBSERVER_HPP_
-#define OBSERVER_HPP_
+#ifndef OBSERVER_HPP
+#define OBSERVER_HPP
 
-#include "universalswitch.hpp"
+#include "UniversalSwitchLog.hpp"
 
 #include <memory>
 
 template<typename T>
 class Observer {
 public:
-       void update(std::shared_ptr<T> item) {
-               INFO("updated: %p", item.get());
-       }
+       virtual void update(const std::shared_ptr<T> &item) = 0;
 };
 
 #endif

diff --git a/src/QueryBuilder.cpp b/src/QueryBuilder.cpp
index 196499c..aa4308b 100644 (file)
--- a/src/QueryBuilder.cpp
+++ b/src/QueryBuilder.cpp
@@ -1,6 +1,6 @@
 #include "QueryBuilder.hpp"
 
-#include "universalswitch.hpp"
+#include "UniversalSwitchLog.hpp"
 
 QueryBuilder &QueryBuilder::select(const std::initializer_list<std::string> &list) {
        query << "select ";
@@ -19,7 +19,7 @@ QueryBuilder &QueryBuilder::select(const std::initializer_list<std::string> &lis
 }
 
 QueryBuilder &QueryBuilder::from(const std::string &s) {
-       query << "from " << s << " ";
+       query << " from " << s << " ";
 
        printDebug();
        return *this;

diff --git a/src/SQLiteConfiguration.cpp b/src/SQLiteConfiguration.cpp
index c9ca0a2..f39123b 100644 (file)
--- a/src/SQLiteConfiguration.cpp
+++ b/src/SQLiteConfiguration.cpp
@@ -4,55 +4,50 @@
 
 #include "QueryBuilder.hpp"
 
-SQLiteConfiguration &SQLiteConfiguration::instance()
-{
-       static SQLiteConfiguration instance;
-       return instance;
-}
-
-SQLiteConfiguration::SQLiteConfiguration()
-       : password("UniversalSwitchPassword"), dbName("UniversalSwitch.db"), tableName("`UNIVERSAL_SWITCH`"),
-         switchIdCol("`SWITCH_ID`"), /*providerIdCol("`PROVIDER_ID`"),*/ userNameCol("`USER_NAME`"),
+SQLiteConfiguration::SQLiteConfiguration(bool createInMemory)
+       : password("UniversalSwitchPassword"), dbName(createInMemory ? ":memory:" : "UniversalSwitch.db"), tableName("`UNIVERSAL_SWITCH`"),
+         switchIdCol("`SWITCH_ID`"), userNameCol("`USER_NAME`"),
          activityTypeCol("`ACTIVITY_TYPE`")
 {
-       initialize();
-}
-
-SQLiteConfiguration::~SQLiteConfiguration()
-{
-       sqlite3_close(dbHandler);
-       sqlite3_shutdown();
-}
-
-void SQLiteConfiguration::initialize()
-{
        sqlite3_shutdown();
 
        sqlite3_config(SQLITE_CONFIG_URI, 1);
        sqlite3_initialize();
 
-       auto resource = app_get_data_path();
-       if (!resource)
-               ERROR("app_get_data_path() failed");
+       std::string path;
+       if (createInMemory) {
+               auto resource = app_get_data_path();
+               if (!resource)
+                       ERROR("app_get_data_path() failed");
 
-       auto path = std::string(resource ? resource : "") + dbName;
-       free(resource);
+               path = (resource ? resource : "") + dbName;
+               free(resource);
+       } else
+               path = dbName;
 
-       if (sqlite3_open(path.c_str(), &dbHandler) != SQLITE_OK)
+       if (sqlite3_open(path.c_str(), &dbHandler) != SQLITE_OK) {
                ERROR("sqlite3_open() failed");
+               throw std::runtime_error("SQLite connection failed");
+       }
 
        sqlite3_update_hook(dbHandler, update_callback, nullptr);
        createTable();
 }
 
+SQLiteConfiguration::~SQLiteConfiguration()
+{
+       sqlite3_close(dbHandler);
+       sqlite3_shutdown();
+}
+
 void SQLiteConfiguration::add(const std::shared_ptr<SwitchConfigurationItem> &item)
 {
        auto query = QueryBuilder().insertInto(tableName).values({item->getSwitchId(),
-                                                          /*item.get()->getProviderId(),*/
                                                                                                           item->getUserName(),
                                                                                                           item->getActivityType()
                                                                                                   }).build();
 
+       item->setChangeType(ChangeType::ADD);
        if (executeQuery(query))
                notify(item);
 }
@@ -68,6 +63,7 @@ void SQLiteConfiguration::update(const std::shared_ptr<SwitchConfigurationItem>
 
        INFO("update query: %s", query.c_str());
 
+       item->setChangeType(ChangeType::UPDATE);
        if (executeQuery(query))
                notify(item);
 }
@@ -86,6 +82,7 @@ void SQLiteConfiguration::remove(const std::string &switchId)
        auto query = QueryBuilder().deleteFrom(tableName).where(switchIdCol, "=", switchId).build();
 
        INFO("remove query: %s", query.c_str());
+       item->setChangeType(ChangeType::REMOVE);
        if (executeQuery(query))
                notify(item);
 }
@@ -117,7 +114,6 @@ std::vector<std::shared_ptr<SwitchConfigurationItem>> SQLiteConfiguration::findA
                return {};
 
        return collection;
-
 }
 
 static int call_functor(void *data, int argc, char **argv, char **colName)
@@ -161,7 +157,6 @@ void SQLiteConfiguration::createTable()
 {
        auto query = "CREATE TABLE IF NOT EXISTS " + tableName + "("
                                                + switchIdCol + " TEXT NOT NULL, "
-                                               // + providerIdCol + " TEXT NOT NULL, "
                                                + userNameCol + " TEXT, "
                                                + activityTypeCol + " TEXT NOT NULL, "
                                                + "PRIMARY KEY (" + switchIdCol + "));";

diff --git a/src/SQLiteConfiguration.hpp b/src/SQLiteConfiguration.hpp
index 8c17fbf..2cb0ce1 100644 (file)
--- a/src/SQLiteConfiguration.hpp
+++ b/src/SQLiteConfiguration.hpp
@@ -11,11 +11,13 @@
 
 #include <string>
 #include <functional>
+#include <memory>
 
 class SQLiteConfiguration : public Configuration
 {
 public:
-       static SQLiteConfiguration &instance();
+       SQLiteConfiguration(bool createInMemory = false);
+       ~SQLiteConfiguration();
 
        void add(const std::shared_ptr<SwitchConfigurationItem> &item) override;
        void update(const std::shared_ptr<SwitchConfigurationItem> &item) override;
@@ -28,11 +30,6 @@ public:
 
        using execCallback_t = std::function<void(int, char **, char **)>;
 private:
-       SQLiteConfiguration();
-       ~SQLiteConfiguration();
-
-       void initialize();
-
        bool executeQuery(const std::string &query, const execCallback_t &cb) const;
        bool executeQuery(const std::string &query) const;
        void createTable();
@@ -44,7 +41,6 @@ private:
        const std::string tableName;
 
        const std::string switchIdCol;
-       // const std::string providerIdCol;
        const std::string userNameCol;
        const std::string activityTypeCol;
 

diff --git a/src/Subject.hpp b/src/Subject.hpp
index 7f766e9..2d5ed02 100644 (file)
--- a/src/Subject.hpp
+++ b/src/Subject.hpp
@@ -1,5 +1,5 @@
-#ifndef SUBJECT_HPP_
-#define SUBJECT_HPP_
+#ifndef SUBJECT_HPP
+#define SUBJECT_HPP
 
 #include "Condition.hpp"
 #include "Observer.hpp"
@@ -15,14 +15,17 @@ public:
                observers.emplace_back(std::move(observer), std::move(cond));
        }
 
-       void detach(const Observer<T> *observer, const Condition<T> *cond)
+       void detach(const Observer<T> *observer, const T *item)
        {
-               for (auto it = observers.begin(); it != observers.end(); ++it)
-                       if (it->first.get() == observer && it->second.get() == cond) {
+               for (auto it = observers.begin(); it != observers.end(); ++it) {
+                       auto tempObserver = it->first.lock();
+
+                       if (tempObserver.get() == observer && it->second->getItem().get() == item) {
                                *it = std::move(observers.back());
                                observers.pop_back();
                                break;
                        }
+               }
        }
 
 protected:

diff --git a/src/Switch.cpp b/src/Switch.cpp
index a80ed27..9e0a96c 100644 (file)
--- a/src/Switch.cpp
+++ b/src/Switch.cpp
@@ -1,16 +1,8 @@
 #include "Switch.hpp"
 
-Switch::Switch(std::string id, std::weak_ptr<const SwitchProvider> provider)
-       : provider(std::move(provider))
-{
-       auto prov = provider.lock();
-       switchId = std::make_shared<SwitchId>(id, prov->getId());
-}
-
-std::weak_ptr<const SwitchProvider> Switch::getProvider() const
-{
-       return provider;
-}
+Switch::Switch(const std::string &switchId, const std::string &providerId)
+       : switchId(std::make_shared<SwitchId>(switchId, providerId))
+{}
 
 bool Switch::operator==(const Switch &sw) const
 {

diff --git a/src/Switch.hpp b/src/Switch.hpp
index 08bd5d5..336f8d4 100644 (file)
--- a/src/Switch.hpp
+++ b/src/Switch.hpp
@@ -1,20 +1,16 @@
 #ifndef SWITCH_HPP
 #define SWITCH_HPP
 
-#include "SwitchProvider.hpp"
 #include "SwitchId.hpp"
 
 #include <string>
 #include <memory>
 
-class SwitchProvider;
-
 class Switch
 {
 public:
-       Switch(std::string id, std::weak_ptr<const SwitchProvider> provider);
+       Switch(const std::string &switchId, const std::string &providerId);
 
-       std::weak_ptr<const SwitchProvider> getProvider() const;
        bool operator==(const Switch &sw) const;
 
        std::shared_ptr<SwitchId> getId() const;
@@ -28,7 +24,6 @@ private:
        std::shared_ptr<SwitchId> switchId;
        std::string name;
        std::string description;
-       std::weak_ptr<const SwitchProvider> provider;
 };
 
 #endif

diff --git a/src/SwitchConfigurationItem.cpp b/src/SwitchConfigurationItem.cpp
index d16253c..00a41df 100644 (file)
--- a/src/SwitchConfigurationItem.cpp
+++ b/src/SwitchConfigurationItem.cpp
@@ -6,14 +6,17 @@ SwitchConfigurationItem::SwitchConfigurationItem(ChangeType type)
        : changeType(type)
 {}
 
-SwitchConfigurationItem::SwitchConfigurationItem(const std::string &switchId, /*const std::string &providerId,*/ const std::string &activityType, ChangeType type)
-       : switchId(switchId), /*providerId(providerId),*/ activityType(activityType), changeType(type)
+SwitchConfigurationItem::SwitchConfigurationItem(const std::string &switchId, const std::string &activityType)
+       : switchId(switchId), activityType(activityType)
+{}
+
+SwitchConfigurationItem::SwitchConfigurationItem(const std::string &switchId, const std::string &activityType, ChangeType type)
+       : switchId(switchId), activityType(activityType), changeType(type)
 {}
 
 bool SwitchConfigurationItem::operator==(const SwitchConfigurationItem &item) const
 {
-       return switchId == item.getSwitchId() /*&& providerId == item.getProviderId()*/
-              && activityType == item.getActivityType() && changeType == item.getChangeType();
+       return switchId == item.getSwitchId() && activityType == item.getActivityType() && changeType == item.getChangeType();
 }
 
 std::string SwitchConfigurationItem::getSwitchId() const
@@ -26,16 +29,6 @@ void SwitchConfigurationItem::setSwitchId(const std::string &switchId)
        this->switchId = switchId;
 }
 
-// std::string SwitchConfigurationItem::getProviderId() const
-// {
-//     return providerId;
-// }
-//
-// void SwitchConfigurationItem::setProviderId(const std::string &providerId)
-// {
-//     this->providerId = providerId;
-// }
-
 std::string SwitchConfigurationItem::getUserName() const {
        return userName;
 }
@@ -74,10 +67,8 @@ void SwitchConfigurationItem::construct(int argc, char **argv, char **azColName)
        }
 
        setSwitchId(argv[static_cast<int>(SwitchConfigurationItemFields::SWITCH_ID)]);
-       // setProviderId(argv[SwitchConfigurationItemFields::PROVIDER_ID]);
        setUserName(argv[static_cast<int>(SwitchConfigurationItemFields::USER_NAME)]);
        setActivityType(argv[static_cast<int>(SwitchConfigurationItemFields::ACTIVITY_TYPE)]);
 
-       // INFO("switchId: %s, providerId: %s, value: %s", switchId.c_str(), /*providerId.c_str(),*/ activityType.c_str());
        INFO("switchId: %s, userName: %s, activityType: %s", switchId.c_str(), userName.c_str(), activityType.c_str());
 }

diff --git a/src/SwitchConfigurationItem.hpp b/src/SwitchConfigurationItem.hpp
index 4b55aa4..1796bd1 100644 (file)
--- a/src/SwitchConfigurationItem.hpp
+++ b/src/SwitchConfigurationItem.hpp
@@ -3,7 +3,7 @@
 
 #include <string>
 
-#include "universalswitch.hpp"
+#include "UniversalSwitchLog.hpp"
 
 enum class ChangeType {
        ADD,
@@ -14,7 +14,6 @@ enum class ChangeType {
 
 enum class SwitchConfigurationItemFields {
        SWITCH_ID,
-       // PROVIDER_ID,
        USER_NAME,
        ACTIVITY_TYPE,
        Count
@@ -25,14 +24,13 @@ class SwitchConfigurationItem
 public:
        SwitchConfigurationItem() = default;
        SwitchConfigurationItem(ChangeType type);
-       SwitchConfigurationItem(const std::string &switchId, /*const std::string &providerId,*/ const std::string &activityType, ChangeType type);
+       SwitchConfigurationItem(const std::string &switchId, const std::string &activityType);
+       SwitchConfigurationItem(const std::string &switchId,  const std::string &activityType, ChangeType type);
 
        bool operator==(const SwitchConfigurationItem &item) const;
 
        std::string getSwitchId() const;
        void setSwitchId(const std::string &switchId);
-       // std::string getProviderId() const;
-       // void setProviderId(const std::string &providerId);
        std::string getUserName() const;
        void setUserName(const std::string &userName);
        std::string getActivityType() const;
@@ -44,7 +42,6 @@ public:
 
 private:
        std::string switchId;
-       // std::string providerId;
        std::string userName;
        std::string activityType;
 

diff --git a/src/SwitchConfigurationItemObserver.hpp b/src/SwitchConfigurationItemObserver.hpp
index 5e86ebb..b3410d6 100644 (file)
--- a/src/SwitchConfigurationItemObserver.hpp
+++ b/src/SwitchConfigurationItemObserver.hpp
@@ -9,4 +9,4 @@ class SwitchConfigurationItemObserver : public Observer<SwitchConfigurationItem>
 
 };
 
-#endif // SWITCH_CONFIGURATION_ITEM_OBSERVER_HPP_
+#endif // SWITCH_CONFIGURATION_ITEM_OBSERVER_HPP

diff --git a/src/SwitchId.hpp b/src/SwitchId.hpp
index 09e5514..c5ae5dd 100644 (file)
--- a/src/SwitchId.hpp
+++ b/src/SwitchId.hpp
@@ -6,7 +6,7 @@
 class SwitchId
 {
 public:
-       SwitchId(const std::string &localId, const std::string providerid);
+       SwitchId(const std::string &localId, const std::string providerId);
 
        bool operator==(const SwitchId &switchId) const;
 

diff --git a/src/SwitchManager.cpp b/src/SwitchManager.cpp
index bb2108e..34cf8ee 100644 (file)
--- a/src/SwitchManager.cpp
+++ b/src/SwitchManager.cpp
@@ -4,27 +4,67 @@
 #include "ConditionEqual.hpp"
 #include "AdHocActivityDispatcher.hpp"
 
-SwitchManager::SwitchManager(std::shared_ptr<SwitchProvider> provider,
-                                        std::shared_ptr<Configuration> configuration,
-                                        std::shared_ptr<ActivityBuilderFactory> factory)
-       : switchProvider(std::move(provider)),
-         configuration(std::move(configuration)),
-         activityBuilderFactory(std::move(factory))
+SwitchManager::SwitchManager(const std::shared_ptr<SwitchProvider> &provider,
+                                        const std::shared_ptr<Configuration> &configuration,
+                                        const std::shared_ptr<ActivityBuilderFactory> &factory)
+       : switchProvider(provider),
+         configuration(configuration),
+         activityBuilderFactory(factory)
 {
        asyncActivityConstructor = std::make_shared<AsyncActivityConstructor>();
        activityDispatcher = std::make_shared<AdHocActivityDispatcher>();
+}
 
-       auto cond = std::unique_ptr<Condition<SwitchConfigurationItem>>(new ConditionAll<SwitchConfigurationItem>);
+void SwitchManager::initialize()
+{
+       auto cond = std::unique_ptr<Condition<SwitchConfigurationItem>>(new ConditionAll<SwitchConfigurationItem>);
        configuration->attach(shared_from_this(), std::move(cond));
 
        auto confItems = configuration->findAll();
 
        for (auto &item : confItems) {
-               auto sw = provider->findSwitchById(item->getSwitchId());
+               auto sw = switchProvider->findSwitchById(item->getSwitchId());
                if (!sw)
                        continue;
 
                auto cond = std::unique_ptr<Condition<Switch>>(new ConditionEqual<Switch>(sw));
-               provider->attach(shared_from_this(), std::move(cond));
+               switchProvider->attach(shared_from_this(), std::move(cond));
        }
 }
+
+void SwitchManager::update(const std::shared_ptr<SwitchConfigurationItem> &item) {
+       switch (item->getChangeType())
+       {
+       case ChangeType::ADD: {
+               auto sw = switchProvider->findSwitchById(item->getSwitchId());
+               if (!sw)
+                       return;
+
+               auto cond = std::unique_ptr<Condition<Switch>>(new ConditionEqual<Switch>(sw));
+               switchProvider->attach(shared_from_this(), std::move(cond));
+
+               break;
+       }
+
+       case ChangeType::UPDATE:
+
+               break;
+
+       case ChangeType::REMOVE: {
+               auto sw = switchProvider->findSwitchById(item->getSwitchId());
+               switchProvider->detach(this, sw.get());
+               break;
+       }
+
+       case ChangeType::NONE:
+               WARNING("Invalid item type");
+       }
+}
+
+void SwitchManager::update(const std::shared_ptr<Switch> &item) {
+
+}
+
+void SwitchManager::update(const std::shared_ptr<Activity> &item) {
+
+}

diff --git a/src/SwitchManager.hpp b/src/SwitchManager.hpp
index fa64d16..4af0f5a 100644 (file)
--- a/src/SwitchManager.hpp
+++ b/src/SwitchManager.hpp
@@ -9,17 +9,33 @@
 #include "Configuration.hpp"
 #include "Condition.hpp"
 #include "ActivityBuilderFactory.hpp"
+#include "Activity.hpp"
 
 #include <memory>
 
-class SwitchManager : public SwitchConfigurationItemObserver, public SwitchObserver, public ActivityObserver, std::enable_shared_from_this<SwitchManager>
+class SwitchManager : public SwitchConfigurationItemObserver, public SwitchObserver, public ActivityObserver, public std::enable_shared_from_this<SwitchManager>
 {
 public:
-       SwitchManager(std::shared_ptr<SwitchProvider> provider,
-                     std::shared_ptr<Configuration> configuration,
-                     std::shared_ptr<ActivityBuilderFactory> factory);
+       void update(const std::shared_ptr<SwitchConfigurationItem> &item) override;
+       void update(const std::shared_ptr<Switch> &item) override;
+       void update(const std::shared_ptr<Activity> &item) override;
+
+       template<class A>
+       static std::shared_ptr<A> create(const std::shared_ptr<SwitchProvider> &provider,
+                                                            const std::shared_ptr<Configuration> &configuration,
+                                                            const std::shared_ptr<ActivityBuilderFactory> &factory) {
+               auto ptr = std::shared_ptr<A>(new A(provider, configuration, factory));
+               ptr->initialize();
+               return ptr;
+       }
+
+protected:
+       SwitchManager(const std::shared_ptr<SwitchProvider> &provider,
+                     const std::shared_ptr<Configuration> &configuration,
+                     const std::shared_ptr<ActivityBuilderFactory> &factory);
+
+       void initialize();
 
-private:
        std::shared_ptr<SwitchProvider> switchProvider;
        std::shared_ptr<Configuration> configuration;
        std::shared_ptr<ActivityBuilderFactory> activityBuilderFactory;

diff --git a/src/SwitchProvider.cpp b/src/SwitchProvider.cpp
index 1f37436..e4d4e54 100644 (file)
--- a/src/SwitchProvider.cpp
+++ b/src/SwitchProvider.cpp
@@ -1,10 +1,10 @@
 #include "SwitchProvider.hpp"
 
-SwitchProvider::SwitchProvider(std::string id)
-       : id(std::move(id))
+SwitchProvider::SwitchProvider(const std::string &switchProviderId)
+       : switchProviderId(switchProviderId)
 {}
 
 std::string SwitchProvider::getId() const
 {
-       return id;
+       return switchProviderId;
 }

diff --git a/src/SwitchProvider.hpp b/src/SwitchProvider.hpp
index ce2803f..5c204ef 100644 (file)
--- a/src/SwitchProvider.hpp
+++ b/src/SwitchProvider.hpp
@@ -8,23 +8,20 @@
 #include <vector>
 #include <memory>
 
-class Switch;
-
 class SwitchProvider : public Subject<Switch>
 {
 public:
        using SwitchCollection = std::vector<std::shared_ptr<Switch>>;
-       using SwitchPtr = std::shared_ptr<const Switch>;
 
        virtual ~SwitchProvider() {};
-       virtual SwitchCollection findAllSwitches() = 0;
-       virtual std::shared_ptr<Switch> findSwitchById(const std::string &id) = 0;
+       virtual SwitchCollection findAllSwitches() const = 0;
+       virtual std::shared_ptr<Switch> findSwitchById(const std::string &switchId) const = 0;
 
        std::string getId() const;
 
 protected:
-       SwitchProvider(std::string id);
-       const std::string id;
+       SwitchProvider(const std::string &id);
+       const std::string switchProviderId;
 };
 
 #endif

diff --git a/src/universalswitch.hpp b/src/UniversalSwitchLog.hpp
similarity index 93%
rename from src/universalswitch.hpp
rename to src/UniversalSwitchLog.hpp
index b65206f..ff18eec 100644 (file)
--- a/src/universalswitch.hpp
+++ b/src/UniversalSwitchLog.hpp
@@ -1,10 +1,12 @@
-#ifndef UNIVERSAL_SWITCH_HPP_
-#define UNIVERSAL_SWITCH_HPP_
+#ifndef UNIVERSAL_SWITCH_HPP
+#define UNIVERSAL_SWITCH_HPP
 
 #include <libintl.h>
 #include <dlog.h>
 #include <Ecore.h>
 
+#include <iostream>
+
 #ifdef  LOG_TAG
 #undef  LOG_TAG
 #endif
@@ -69,4 +71,4 @@
 
 #define _(str) (gettext(str))
 
-#endif /* UNIVERSAL_SWITCH_HPP_ */
+#endif /* UNIVERSAL_SWITCH_HPP */

diff --git a/src/universalswitch.cpp b/src/universalswitch.cpp
index 10b1a6c..4ba8dcf 100644 (file)
--- a/src/universalswitch.cpp
+++ b/src/universalswitch.cpp
@@ -1,4 +1,4 @@
-#include "universalswitch.hpp"
+#include "UniversalSwitchLog.hpp"
 #include "SQLiteConfiguration.hpp"
 
 #include <tizen.h>

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e39f439..06c91cc 100644 (file)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 ADD_SUBDIRECTORY(googletest)
 
 INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src/)
@@ -18,4 +17,4 @@ FUNCTION(CREATE_TEST_FROM_SOURCE TEST_SRC_FILE)
     ADD_TEST(test_${TESTNAME} test_${TESTNAME})
 ENDFUNCTION(CREATE_TEST_FROM_SOURCE)
 
-CREATE_TEST_FROM_SOURCE(main.cpp)
+CREATE_TEST_FROM_SOURCE(ConfigurationTests.cpp)

diff --git a/tests/ConfigurationTests.cpp b/tests/ConfigurationTests.cpp
new file mode 100644 (file)
index 0000000..802702d
--- /dev/null
+++ b/tests/ConfigurationTests.cpp
@@ -0,0 +1,41 @@
+#include "ConfigurationTests.hpp"
+
+TEST_F(ConfigurationFixture, ConfigurationNotEmpty_BeUpdatedOnEvent) {
+       configuration_->add(item_);
+
+       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+       simulateKeyDown();
+
+       EXPECT_EQ(switchManager->updatedWithSwitch, 1);
+       EXPECT_EQ(switchManager->receivedItem->getId()->getGlobalId(), switchId_);
+}
+
+TEST_F(ConfigurationFixture, ConfigurationEmpty_MappingAdded_BeUpdatedOnEvent) {
+       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+       configuration_->add(item_);
+       simulateKeyDown();
+
+       EXPECT_EQ(switchManager->updatedWithSwitch, 1);
+       EXPECT_EQ(switchManager->receivedItem->getId()->getGlobalId(), switchId_);
+}
+
+TEST_F(ConfigurationFixture, MappingAddedAndRemoved_BeNotUpdatedOnEvent) {
+       configuration_->add(item_);
+       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+       configuration_->remove(switchId_);
+       simulateKeyDown();
+
+       EXPECT_EQ(switchManager->updatedWithSwitch, 0);
+}
+
+TEST_F(ConfigurationFixture, MappingAddedAndUpdated_BeUpdatedWithNewValue) {
+       configuration_->add(item_);
+       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+       auto newActivityType = "SCAN_OFF";
+       auto newItem = std::make_shared<SwitchConfigurationItem>(switch_->getId()->getGlobalId(), newActivityType);
+       configuration_->update(newItem);
+       simulateKeyDown();
+
+       EXPECT_EQ(switchManager->updatedWithSwitch, 1);
+       EXPECT_EQ(switchManager->receivedItem->getId()->getGlobalId(), switchId_);
+}

diff --git a/tests/ConfigurationTests.hpp b/tests/ConfigurationTests.hpp
new file mode 100644 (file)
index 0000000..2d6de5c
--- /dev/null
+++ b/tests/ConfigurationTests.hpp
@@ -0,0 +1,73 @@
+#ifndef CONFIGURATION_TESTS_HPP
+#define CONFIGURATION_TESTS_HPP
+
+#include <cmock/cmock.h>
+
+#include "SQLiteConfiguration.hpp"
+#include "AccessoriesSwitchProvider.hpp"
+#include "SwitchConfigurationItem.hpp"
+#include "SwitchManager.hpp"
+
+#include <memory>
+
+using ::testing::StrictMock;
+using ::testing::DoAll;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+using ::testing::StrEq;
+using ::testing::_;
+
+class ConfigurationFixture : public ::testing::Test {
+public:
+       void SetUp() {
+               EXPECT_TRUE(ecore_init());
+               EXPECT_TRUE(ecore_event_init());
+               configuration_ = std::make_shared<SQLiteConfiguration>(true);
+               switchProvider_ = std::make_shared<AccessoriesSwitchProvider>();
+               switch_ = switchProvider_->findSwitchById(switchId_);
+               item_ = std::make_shared<SwitchConfigurationItem>(switch_->getId()->getGlobalId(), activityType_);
+       }
+
+       void TearDown() {
+               ecore_event_shutdown();
+               ecore_shutdown();
+       }
+
+       void simulateKeyDown() {
+               Ecore_Event_Key *event = (Ecore_Event_Key*)malloc(sizeof(Ecore_Event_Key));
+               event->key = key.c_str();
+               EXPECT_TRUE(ecore_event_add(ECORE_EVENT_KEY_DOWN, event, NULL, NULL));
+               ecore_main_loop_iterate();
+       }
+
+protected:
+       std::shared_ptr<Configuration> configuration_;
+       std::shared_ptr<SwitchProvider> switchProvider_;
+       std::shared_ptr<Switch> switch_;
+       std::shared_ptr<SwitchConfigurationItem> item_;
+       std::string key = "Down";
+       std::string switchId_ = "AccessoriesSwitchProvider_Down";
+       std::string activityType_ = "SELECT";
+};
+
+class SwitchManagerMocked : public SwitchManager {
+public:
+
+       SwitchManagerMocked(const std::shared_ptr<SwitchProvider> &provider,
+                     const std::shared_ptr<Configuration> &configuration,
+                     const std::shared_ptr<ActivityBuilderFactory> &factory)
+               : SwitchManager(provider, configuration, factory)
+       {}
+
+       void update(const std::shared_ptr<Switch> &item) override {
+               SwitchManager::update(item);
+               receivedItem = item;
+               ++updatedWithSwitch;
+       }
+
+       int updatedWithSwitch = 0;
+       std::shared_ptr<Switch> receivedItem;
+};
+
+#endif // CONFIGURATION_TESTS_HPP

diff --git a/tests/main.cpp b/tests/main.cpp
deleted file mode 100644 (file)
index fbaa64c..0000000
--- a/tests/main.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <cmock/cmock.h>
-
-using namespace ::testing;
-
-TEST(FooTest, SQLiteUsage) {
-       EXPECT_TRUE(true);
-}