service/scene-manager/unittests/RemoteSceneActionTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2016 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 <mutex>
  22 #include <condition_variable>
  23
  24 #include "RemoteSceneList.h"
  25
  26 #include "UnitTestHelper.h"
  27 #include "SceneCommons.h"
  28 #include "SceneList.h"
  29 #include "RCSResourceObject.h"
  30 #include "RCSRemoteResourceObject.h"
  31 #include "OCPlatform.h"
  32 #include "RCSDiscoveryManager.h"
  33 #include "RCSAddress.h"
  34
  35 using namespace std;
  36 using namespace OIC::Service;
  37 using namespace OC;
  38
  39 constexpr int DEFAULT_WAITTIME = 2000;
  40
  41 constexpr char RESOURCE_URI[]{ "/a/light" };
  42 constexpr char RESOURCE_TYPE[]{ "core.light" };
  43 constexpr char KEY[]{ "power" };
  44 constexpr char VALUE[]{ "off" };
  45
  46 static int lightNum = 0;
  47
  48 SceneList* g_sceneList = SceneList::getInstance();
  49 RCSRemoteResourceObject::Ptr pListResource = nullptr;
  50 RemoteSceneList::Ptr pSceneList = nullptr;
  51 RemoteSceneCollection::Ptr pSceneCollection = nullptr;
  52 RemoteScene::Ptr pScene = nullptr;
  53 RemoteSceneAction::Ptr pSceneAction = nullptr;
  54 RCSRemoteResourceObject::Ptr pLightResource = nullptr;
  55
  56 void discoverSceneListServer()
  57 {
  58     if(pListResource == nullptr)
  59     {
  60         std::vector< std::string > vecRT{ SCENE_LIST_RT };
  61         std::vector< std::string > vecIF{ OC_RSRVD_INTERFACE_DEFAULT, OC::BATCH_INTERFACE };
  62
  63         pListResource = SceneUtils::createRCSResourceObject(
  64                             "coap://" + SceneUtils::getNetAddress() + SCENE_LIST_URI,
  65                             SCENE_CONNECTIVITY, vecRT, vecIF);
  66     }
  67 }
  68
  69 class RemoteSceneActionTest : public TestWithMock
  70 {
  71 protected:
  72     void SetUp()
  73     {
  74         TestWithMock::SetUp();
  75
  76         g_sceneList->getName();
  77         discoverSceneListServer();
  78
  79         if(pSceneList == nullptr)
  80         {
  81             RemoteSceneList::createInstance(pListResource, std::bind(
  82                 &RemoteSceneActionTest::onRemoteSceneListCreated, this,
  83                 placeholders::_1, placeholders::_2));
  84
  85             waitForCallback();
  86         }
  87
  88         if(pSceneCollection == nullptr)
  89         {
  90             pSceneList->addNewSceneCollection(std::bind(
  91                 &RemoteSceneActionTest::onRemoteSceneCollectionCreated, this,
  92                 placeholders::_1, placeholders::_2));
  93
  94             waitForCallback();
  95         }
  96
  97         if(pScene == nullptr)
  98         {
  99             pSceneCollection->addNewScene("Test Scene", std::bind(
 100                 &RemoteSceneActionTest::onRemoteSceneCreated, this,
 101                 placeholders::_1, placeholders::_2));
 102
 103             waitForCallback();
 104         }
 105     }
 106
 107     void createLightServer()
 108     {
 109         if(pLightResource != nullptr)
 110         {
 111             return ;
 112         }
 113
 114         RCSResourceObject::Ptr pResource = RCSResourceObject::Builder(
 115             RESOURCE_URI, RESOURCE_TYPE, DEFAULT_INTERFACE).build();
 116         pResource->setAttribute(KEY, RCSResourceAttributes::Value(VALUE));
 117
 118         pLightResource
 119             = SceneUtils::createRCSResourceObject(
 120             "coap://" + SceneUtils::getNetAddress() + RESOURCE_URI
 121             + "/" + std::to_string(lightNum++),
 122             (OCConnectivityType)(CT_ADAPTER_IP|CT_IP_USE_V4),
 123             pResource->getTypes(), pResource->getInterfaces());
 124     }
 125
 126     void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
 127     {
 128         std::unique_lock< std::mutex > lock{ mutex };
 129         cond.wait_for(lock, std::chrono::milliseconds{ waitingTime });
 130     }
 131
 132 public:
 133     bool executionSucceeded;
 134     std::condition_variable cond;
 135     std::mutex mutex;
 136
 137     void onRemoteSceneListCreated(RemoteSceneList::Ptr remoteSceneList, int)
 138     {
 139         pSceneList = std::move(remoteSceneList);
 140         cond.notify_all();
 141     }
 142
 143     void onRemoteSceneCollectionCreated(RemoteSceneCollection::Ptr remoteSceneCol, int)
 144     {
 145         pSceneCollection = remoteSceneCol;
 146         cond.notify_all();
 147     }
 148
 149     void onRemoteSceneCreated(RemoteScene::Ptr remoteScene, int)
 150     {
 151         pScene = remoteScene;
 152         cond.notify_all();
 153     }
 154
 155     void onRemoteSceneActionCreated(RemoteSceneAction::Ptr remoteSceneAction, int)
 156     {
 157         pSceneAction = remoteSceneAction;
 158         cond.notify_all();
 159     }
 160
 161     void onActionUpdated(int)
 162     {
 163         cond.notify_all();
 164     }
 165 };
 166
 167 TEST_F(RemoteSceneActionTest, createSceneAction)
 168 {
 169     createLightServer();
 170
 171     if(pSceneAction == nullptr)
 172     {
 173         pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
 174             std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
 175             placeholders::_1, placeholders::_2));
 176         waitForCallback();
 177     }
 178
 179     ASSERT_NE(nullptr, pSceneAction);
 180 }
 181
 182 TEST_F(RemoteSceneActionTest, createSceneActionWithEmptyRCSRemoteResourceObjectPtr)
 183 {
 184     ASSERT_THROW(pScene->addNewSceneAction(nullptr, KEY, RCSResourceAttributes::Value(VALUE),
 185         std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
 186         placeholders::_1, placeholders::_2)), RCSInvalidParameterException);
 187 }
 188
 189 TEST_F(RemoteSceneActionTest, getAllRemoteSceneActions)
 190 {
 191     createLightServer();
 192
 193     if(pSceneAction == nullptr)
 194     {
 195         pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
 196             std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
 197             placeholders::_1, placeholders::_2));
 198         waitForCallback();
 199     }
 200
 201     vector< RemoteSceneAction::Ptr > actions
 202         = pScene->getRemoteSceneActions();
 203
 204     ASSERT_EQ((unsigned int)1, actions.size());
 205     ASSERT_TRUE(actions.at(0)->getExecutionParameter().contains(KEY));
 206     ASSERT_EQ(VALUE, actions.at(0)->getExecutionParameter().at(KEY).get< string >());
 207 }
 208
 209 TEST_F(RemoteSceneActionTest, getRemoteSceneAction)
 210 {
 211     createLightServer();
 212
 213     if(pSceneAction == nullptr)
 214     {
 215         pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
 216             std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
 217             placeholders::_1, placeholders::_2));
 218         waitForCallback();
 219     }
 220
 221     RemoteSceneAction::Ptr action = pScene->getRemoteSceneAction(pLightResource);
 222
 223     ASSERT_TRUE(action->getExecutionParameter().contains(KEY));
 224     ASSERT_EQ(VALUE, action->getExecutionParameter().at(KEY).get< string >());
 225 }
 226
 227 TEST_F(RemoteSceneActionTest, updateSceneAction)
 228 {
 229     createLightServer();
 230
 231     if(pSceneAction == nullptr)
 232     {
 233         pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
 234             std::bind(&RemoteSceneActionTest::onRemoteSceneActionCreated, this,
 235             placeholders::_1, placeholders::_2));
 236         waitForCallback();
 237     }
 238
 239     pSceneAction->resetExecutionParameter(
 240         KEY, RCSResourceAttributes::Value("on"), std::bind(&RemoteSceneActionTest::onActionUpdated, this,
 241         placeholders::_1));
 242
 243     waitForCallback();
 244
 245     ASSERT_EQ("on", pSceneAction->getExecutionParameter().at(KEY).get< string >());
 246 }