#69 Implement UserScripts and IUserScriptFactory

ColinDuquesnoy · Sep 24, 2017 · 09754ff · 09754ff
1 parent ebc3e79
commit 09754ff
Show file tree

Hide file tree

Showing 7 changed files with 251 additions and 16 deletions.
diff --git a/lib/MellowPlayer/Application/UserScripts/IUserScriptFactory.hpp b/lib/MellowPlayer/Application/UserScripts/IUserScriptFactory.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace MellowPlayer::Application
+{
+    class IUserScript;
+
+    class IUserScriptFactory
+    {
+    public:
+        virtual ~IUserScriptFactory() = default;
+        virtual IUserScript* create() const = 0;
+    };
+}
diff --git a/lib/MellowPlayer/Application/UserScripts/UserScripts.cpp b/lib/MellowPlayer/Application/UserScripts/UserScripts.cpp
@@ -1,19 +1,27 @@
 #include "IUserScript.hpp"
+#include "IUserScriptFactory.hpp"
 #include "UserScripts.hpp"
 #include <MellowPlayer/Application/Settings/ISettingsProvider.hpp>
 
 using namespace MellowPlayer::Application;
 
-UserScripts::UserScripts(const QString& serviceName, ISettingsProvider& settingsProvider):
+UserScripts::UserScripts(const QString& serviceName,
+                         IUserScriptFactory& userScriptFactory,
+                         ISettingsProvider& settingsProvider):
     serviceName_(serviceName),
+    userScriptFactory_(userScriptFactory),
     settingsProvider_(settingsProvider)
 {
-    auto scriptPaths = settingsProvider.value(serviceName + "/userScriptPaths", QStringList()).toStringList();
-    auto scriptNames = settingsProvider.value(serviceName + "/userScriptNames", QStringList()).toStringList();
+    auto scriptPaths = settingsProvider.value(pathsKey(), QStringList()).toStringList();
+    auto scriptNames = settingsProvider.value(namesKey(), QStringList()).toStringList();
 
-    for (int i = 0; scriptPaths.count(); ++i) {
-        auto path = scriptPaths[i];
-        auto name = scriptNames[i];
+    for (int i = 0; i < scriptPaths.count(); ++i) {
+        auto path = scriptPaths.at(i);
+        auto name = scriptNames.at(i);
+        auto* userScript = userScriptFactory_.create();
+        userScript->setName(name);
+        userScript->load(path);
+        _scripts.append(userScript);
     }
 }
 
@@ -24,17 +32,41 @@ UserScripts::~UserScripts()
 
 int UserScripts::count() const
 {
-    return 0;
+    return _scripts.count();
 }
 
-void UserScripts::add(IUserScript* userScript)
+void UserScripts::add(const QString& userScriptName, const QString& sourceScriptPath)
 {
-    Q_UNUSED(userScript);
+    auto* userScript = userScriptFactory_.create();
+    userScript->setName(userScriptName);
+    userScript->import(sourceScriptPath);
+
+    _scripts.append(userScript);
+
+    save(userScriptName, userScript);
+
+}
+
+void UserScripts::save(const QString& userScriptName, const IUserScript* userScript) const
+{
+    auto scriptPaths = settingsProvider_.value(pathsKey(), QStringList()).toStringList();
+    scriptPaths.append(userScript->path());
+    auto scriptNames = settingsProvider_.value(namesKey(), QStringList()).toStringList();
+    scriptNames.append(userScriptName);
+    settingsProvider_.setValue(pathsKey(), scriptPaths);
+    settingsProvider_.setValue(namesKey(), scriptNames);
 }
 
 void UserScripts::remove(const QString& scriptName)
 {
-    Q_UNUSED(scriptName);
+    int index = 0;
+    for (index = 0; index < _scripts.count(); ++index) {
+        if (_scripts.at(index)->name() == scriptName) {
+            _scripts.removeAt(index);
+            break;
+        }
+    }
+
 }
 
 UserScripts::const_iterator UserScripts::begin(void) const
@@ -46,3 +78,13 @@ UserScripts::const_iterator UserScripts::end(void) const
 {
     return _scripts.end();
 }
+
+QString UserScripts::pathsKey() const
+{
+    return serviceName_ + "/userScriptPaths";
+}
+
+QString UserScripts::namesKey() const
+{
+    return serviceName_ + "/userScriptNames";
+}
diff --git a/lib/MellowPlayer/Application/UserScripts/UserScripts.hpp b/lib/MellowPlayer/Application/UserScripts/UserScripts.hpp
@@ -6,24 +6,33 @@ namespace MellowPlayer::Application
 {
     class ISettingsProvider;
     class IUserScript;
-
+    class IUserScriptFactory;
+
     class UserScripts
     {
     public:
-        UserScripts(const QString& serviceName, ISettingsProvider& settingsProvider);
+        UserScripts(const QString& serviceName,
+                    IUserScriptFactory& userScriptFactory,
+                    ISettingsProvider& settingsProvider);
         ~UserScripts();
-        
+
         int count() const;
-        void add(IUserScript* userScript);
+        void add(const QString& userScriptName, const QString& sourceScriptPath);
         void remove(const QString& scriptName);
-        
+
         typedef typename QList<IUserScript*>::const_iterator const_iterator;
         const_iterator begin(void) const;
         const_iterator end(void) const;
 
     private:
+        QString pathsKey() const;
+        QString namesKey() const;
+
         QString serviceName_;
+        IUserScriptFactory& userScriptFactory_;
         ISettingsProvider& settingsProvider_;
-        QList<IUserScript*> _scripts;        
+        QList<IUserScript*> _scripts;
+
+        void save(const QString& userScriptName, const IUserScript* userScript) const;
     };
 }
diff --git a/lib/MellowPlayer/Infrastructure/UserScripts/UserScriptFactory.cpp b/lib/MellowPlayer/Infrastructure/UserScripts/UserScriptFactory.cpp
@@ -0,0 +1,10 @@
+#include "UserScriptFactory.hpp"
+#include "UserScript.hpp"
+
+using namespace MellowPlayer::Application;
+using namespace MellowPlayer::Infrastructure;
+
+IUserScript* MellowPlayer::Infrastructure::UserScriptFactory::create() const
+{
+    return new UserScript;
+}
diff --git a/lib/MellowPlayer/Infrastructure/UserScripts/UserScriptFactory.hpp b/lib/MellowPlayer/Infrastructure/UserScripts/UserScriptFactory.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <MellowPlayer/Application/UserScripts/IUserScriptFactory.hpp>
+
+namespace MellowPlayer::Infrastructure
+{
+    class UserScriptFactory: public Application::IUserScriptFactory
+    {
+    public:
+        Application::IUserScript* create() const override;
+
+    };
+}
diff --git a/tests/UnitTests/Application/UserScripts/UserScriptsTests.cpp b/tests/UnitTests/Application/UserScripts/UserScriptsTests.cpp
@@ -0,0 +1,125 @@
+#include <catch.hpp>
+#include <fakeit.hpp>
+#include <MellowPlayer/Application/UserScripts/IUserScript.hpp>
+#include <MellowPlayer/Application/UserScripts/IUserScriptFactory.hpp>
+#include <MellowPlayer/Application/UserScripts/UserScripts.hpp>
+#include <MellowPlayer/Application/Settings/ISettingsProvider.hpp>
+#include <Mocks/SettingsProviderMock.hpp>
+
+using namespace fakeit;
+using namespace MellowPlayer::Application;
+
+SCENARIO("UserScriptsTests")
+{
+    Mock<IUserScript> userScriptMock;
+    When(Method(userScriptMock, path)).AlwaysReturn("/path");
+    When(Method(userScriptMock, code)).AlwaysReturn("code");
+    When(Method(userScriptMock, name)).AlwaysReturn("name");
+    Fake(Method(userScriptMock, setName));
+    When(Method(userScriptMock, load)).AlwaysReturn(true);
+    When(Method(userScriptMock, import)).AlwaysReturn(true);
+    Fake(Dtor(userScriptMock));
+    IUserScript& userScript = userScriptMock.get();
+
+    Mock<IUserScriptFactory> factoryMock;
+    When(Method(factoryMock, create)).AlwaysReturn(&userScript);
+
+    QString serviceName = "fakeService";
+    auto settingsProviderMock = SettingsProviderMock::get();
+    ISettingsProvider& settingsProvider = settingsProviderMock.get();
+    settingsProvider.clear();
+
+
+    GIVEN("empty settings")
+    {
+        UserScripts userScripts(serviceName, factoryMock.get(), settingsProvider);
+
+        WHEN("get count")
+        {
+            THEN("count is zero")
+            {
+                REQUIRE(userScripts.count() == 0);
+            }
+        }
+
+        WHEN("add script")
+        {
+            userScripts.add("name", "/path");
+
+            THEN("factory is called")
+            {
+                Verify(Method(factoryMock, create)).Exactly(1);
+
+                AND_THEN("name is set")
+                {
+                    Verify(Method(userScriptMock, setName)).Exactly(1);
+
+                    AND_THEN("import is called")
+                    {
+                        Verify(Method(userScriptMock, import)).Exactly(1);
+
+                        AND_THEN("count is 1")
+                        {
+                            REQUIRE(userScripts.count() == 1);
+
+                            AND_THEN("settings are saved")
+                            {
+                                REQUIRE(settingsProvider.value("fakeService/userScriptPaths", QStringList()).toStringList().count() == 1);
+                                REQUIRE(settingsProvider.value("fakeService/userScriptNames", QStringList()).toStringList().count() == 1);
+                            }
+                        }
+                    }
+                }
+            }
+
+            AND_WHEN("remove is called")
+            {
+                userScripts.remove("name");
+
+                THEN("count is zero")
+                {
+                    REQUIRE(userScripts.count() == 0);
+                }
+            }
+        }
+    }
+
+    GIVEN("2 scripts in settings")
+    {
+        QStringList paths;
+        paths << "/path2";
+        paths << "/path2";
+        settingsProvider.setValue("fakeService/userScriptPaths", paths);
+
+        QStringList names;
+        names << "name1";
+        names << "name2";
+        settingsProvider.setValue("fakeService/userScriptNames", names);
+
+        WHEN("creating a UserScripts instance")
+        {
+            UserScripts userScripts(serviceName, factoryMock.get(), settingsProvider);
+
+            THEN("factory called once")
+            {
+                Verify(Method(factoryMock, create)).Exactly(2);
+
+                AND_THEN("name is set")
+                {
+                    Verify(Method(userScriptMock, setName)).Exactly(2);
+
+                    AND_THEN("load is called")
+                    {
+                        Verify(Method(userScriptMock, load)).Exactly(2);
+
+                        AND_THEN("count is 2")
+                        {
+                            REQUIRE(userScripts.count() == 2);
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}
diff --git a/tests/UnitTests/Infrastructure/UserScripts/UserScriptFactoryTests.cpp b/tests/UnitTests/Infrastructure/UserScripts/UserScriptFactoryTests.cpp
@@ -0,0 +1,23 @@
+#include <catch.hpp>
+#include <MellowPlayer/Infrastructure/UserScripts/UserScriptFactory.hpp>
+
+using namespace MellowPlayer::Application;
+using namespace MellowPlayer::Infrastructure;
+
+SCENARIO("UserScriptFactoryTests")
+{
+    GIVEN("an instance of userscript factory")
+    {
+        UserScriptFactory factory;
+
+        WHEN("call create")
+        {
+            auto* userScript = factory.create();
+
+            THEN("created user script is not null")
+            {
+                REQUIRE(userScript != nullptr);    
+            }
+        }
+    }
+}