service/scene-manager/unittests/SceneTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "UnitTestHelper.h"
  22
  23 #include "SceneList.h"
  24
  25 #include "RCSResourceObject.h"
  26 #include "RCSRemoteResourceObject.h"
  27 #include "SceneCommons.h"
  28 #include "OCPlatform.h"
  29
  30 #include <condition_variable>
  31 #include <mutex>
  32 #include <iostream>
  33
  34 using namespace std;
  35 using namespace OIC::Service;
  36 using namespace OC;
  37
  38 typedef std::function<void (int)> ExecuteCallback;
  39
  40 constexpr char RESOURCE_URI[]{ "/a/light" };
  41 constexpr char RESOURCE_TYPE[]{ "core.light" };
  42 constexpr char RESOURCE_URI2[]{ "/a/fan" };
  43 constexpr char RESOURCE_TYPE2[]{ "core.fan" };
  44 constexpr char KEY[]{ "power" };
  45 constexpr char VALUE[]{ "off" };
  46 constexpr char KEY_2[]{ "state" };
  47 constexpr char VALUE_2[]{ "100" };
  48
  49 class SceneTest: public TestWithMock
  50 {
  51 protected:
  52     void SetUp()
  53     {
  54         TestWithMock::SetUp();
  55         pSceneList = SceneList::getInstance();
  56     }
  57     void waitForCb(int watingTime)
  58     {
  59         std::unique_lock< std::mutex > lock{ mutex };
  60         cond.wait_for(lock, std::chrono::milliseconds{ watingTime });
  61     }
  62     void proceed()
  63     {
  64         cond.notify_all();
  65     }
  66     void createSceneCollection()
  67     {
  68         pSceneCollection = pSceneList->addNewSceneCollection();
  69     }
  70     void createScene()
  71     {
  72         pScene1 = pSceneCollection->addNewScene("SceneTestName_1");
  73         pScene2 = pSceneCollection->addNewScene("SceneTestName_2");
  74     }
  75     void createServer(const std::string& resourceUri1, const std::string& resourceUri2)
  76     {
  77         auto pResource1 = RCSResourceObject::Builder(
  78                 resourceUri1, RESOURCE_TYPE, DEFAULT_INTERFACE).build();
  79         pResource1->setAttribute(KEY, VALUE);
  80
  81         auto ocResourcePtr = OC::OCPlatform::constructResourceObject(
  82                 "coap://" + SceneUtils::getNetAddress(), resourceUri1,
  83                 OCConnectivityType::CT_ADAPTER_IP, false,
  84                 pResource1->getTypes(), pResource1->getInterfaces());
  85         pRemoteResource1 = RCSRemoteResourceObject::fromOCResource(ocResourcePtr);
  86
  87         auto pResource2 = RCSResourceObject::Builder(
  88                 resourceUri2, RESOURCE_TYPE2, DEFAULT_INTERFACE).build();
  89         pResource2->setAttribute(KEY_2, VALUE_2);
  90
  91         ocResourcePtr = OC::OCPlatform::constructResourceObject(
  92                         "coap://" + SceneUtils::getNetAddress(), resourceUri2,
  93                         OCConnectivityType::CT_ADAPTER_IP, false,
  94                         pResource2->getTypes(), pResource2->getInterfaces());
  95         pRemoteResource2 = RCSRemoteResourceObject::fromOCResource(ocResourcePtr);
  96     }
  97
  98 public:
  99     SceneList* pSceneList;
 100     shared_ptr<SceneCollection> pSceneCollection;
 101     shared_ptr<Scene> pScene1;
 102     shared_ptr<Scene> pScene2;
 103     RCSRemoteResourceObject::Ptr pRemoteResource1;
 104     RCSRemoteResourceObject::Ptr pRemoteResource2;
 105
 106 private:
 107     std::condition_variable cond;
 108     std::mutex mutex;
 109 };
 110 void executeCallback(int /*code*/) {};
 111
 112 TEST_F(SceneTest, createSceneInstance)
 113 {
 114     createSceneCollection();
 115     createScene();
 116     ASSERT_EQ("SceneTestName_1", pScene1->getName());
 117     ASSERT_EQ("SceneTestName_2", pScene2->getName());
 118 }
 119
 120 TEST_F(SceneTest, createSceneInstanceByEmptyName)
 121 {
 122     createSceneCollection();
 123     ASSERT_THROW(pSceneCollection->addNewScene(""), RCSInvalidParameterException);
 124 }
 125
 126 TEST_F(SceneTest, getSceneInstanceBySceneName)
 127 {
 128     createSceneCollection();
 129     createScene();
 130     auto scene = pSceneCollection->getScene("SceneTestName_2");
 131     EXPECT_EQ("SceneTestName_2", scene->getName());
 132 }
 133
 134 TEST_F(SceneTest, getAllSceneInstance)
 135 {
 136     createSceneCollection();
 137     createScene();
 138
 139     vector<string> sceneNames{"SceneTestName_1", "SceneTestName_2"};
 140     auto scenes = pSceneCollection->getScenes();
 141     int count = 0;
 142
 143     for(const auto &it : scenes)
 144     {
 145         for (const auto &name : sceneNames)
 146         {
 147                 if(it.first == name)
 148                 {
 149                         count++;
 150                         break;
 151                 }
 152         }
 153     }
 154     ASSERT_EQ(count, 2);
 155 }
 156
 157 TEST_F(SceneTest, getSceneActionUsingRemoteResource)
 158 {
 159     createServer(RESOURCE_URI, RESOURCE_URI2);
 160     createSceneCollection();
 161     createScene();
 162
 163     auto pSceneAction1 = pScene1->addNewSceneAction(pRemoteResource1, KEY, VALUE);
 164     pSceneAction1->resetExecutionParameter(KEY_2, VALUE_2);
 165
 166     ASSERT_EQ(pScene1->getSceneAction(pRemoteResource1)->getExecutionParameter(),
 167             pSceneAction1->getExecutionParameter());
 168 }
 169
 170 TEST_F(SceneTest, getSceneActions)
 171 {
 172     createServer("/a/testuri1_1", "/a/testuri1_2");
 173     createSceneCollection();
 174     createScene();
 175
 176     auto pSceneAction1 = pScene1->addNewSceneAction(pRemoteResource1, KEY, VALUE);
 177     auto pSceneAction2 = pScene1->addNewSceneAction(pRemoteResource2, KEY, VALUE);
 178
 179     for(const auto & it : pScene1->getSceneActions())
 180     {
 181         ASSERT_EQ(it->getExecutionParameter(), pSceneAction1->getExecutionParameter());
 182     }
 183 }
 184
 185 TEST_F(SceneTest, executeScene)
 186 {
 187     mocks.ExpectCallFunc(executeCallback).Do([this](int){ proceed(); });
 188
 189     createServer("/a/testuri2_1", "/a/testuri2_2");
 190     createSceneCollection();
 191     createScene();
 192     pScene1->addNewSceneAction(pRemoteResource1, KEY, "on");
 193     pScene1->addNewSceneAction(pRemoteResource2, KEY_2, VALUE_2);
 194
 195     pScene1->execute(executeCallback);
 196     waitForCb(100);
 197 }
 198
 199 TEST_F(SceneTest, executeSceneUsingEmptyCallback)
 200 {
 201     createServer("/a/testuri3_1", "/a/testuri3_2");
 202     createSceneCollection();
 203     createScene();
 204     pScene1->addNewSceneAction(pRemoteResource1, KEY, "on");
 205     pScene1->addNewSceneAction(pRemoteResource2, KEY_2, VALUE_2);
 206
 207     ASSERT_THROW(pScene1->execute(nullptr), RCSInvalidParameterException);
 208 }