service/scene-manager/unittests/RemoteSceneTest.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 <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 RemoteSceneTest : public TestWithMock
  70 {
  71 protected:
  72     void SetUp()
  73     {
  74         TestWithMock::SetUp();
  75         executionSucceeded = false;
  76
  77         g_sceneList->getName();
  78         discoverSceneListServer();
  79
  80         if(pSceneList == nullptr)
  81         {
  82             RemoteSceneList::createInstance(pListResource, std::bind(
  83                 &RemoteSceneTest::onRemoteSceneListCreated, this,
  84                 placeholders::_1, placeholders::_2));
  85
  86             waitForCallback();
  87         }
  88
  89         if(pSceneCollection == nullptr)
  90         {
  91             pSceneList->addNewSceneCollection(std::bind(
  92                 &RemoteSceneTest::onRemoteSceneCollectionCreated, this,
  93                 placeholders::_1, placeholders::_2));
  94
  95             waitForCallback();
  96         }
  97     }
  98
  99     void createLightServer()
 100     {
 101         if(pLightResource != nullptr)
 102         {
 103             return ;
 104         }
 105
 106         RCSResourceObject::Ptr pResource = RCSResourceObject::Builder(
 107             RESOURCE_URI, RESOURCE_TYPE, DEFAULT_INTERFACE).build();
 108         pResource->setAttribute(KEY, RCSResourceAttributes::Value(VALUE));
 109
 110         pLightResource
 111             = SceneUtils::createRCSResourceObject(
 112             "coap://" + SceneUtils::getNetAddress() + RESOURCE_URI
 113             + "/" + std::to_string(lightNum++),
 114             (OCConnectivityType)(CT_ADAPTER_IP|CT_IP_USE_V4),
 115             pResource->getTypes(), pResource->getInterfaces());
 116
 117     }
 118
 119     void waitForCallback(int waitingTime = DEFAULT_WAITTIME)
 120     {
 121         std::unique_lock< std::mutex > lock{ mutex };
 122         cond.wait_for(lock, std::chrono::milliseconds{ waitingTime });
 123     }
 124
 125 public:
 126     bool executionSucceeded;
 127     std::condition_variable cond;
 128     std::mutex mutex;
 129
 130     void onRemoteSceneListCreated(RemoteSceneList::Ptr remoteSceneList, int)
 131     {
 132         pSceneList = std::move(remoteSceneList);
 133         cond.notify_all();
 134     }
 135
 136     void onRemoteSceneCollectionCreated(RemoteSceneCollection::Ptr remoteSceneCol, int)
 137     {
 138         pSceneCollection = remoteSceneCol;
 139         cond.notify_all();
 140     }
 141
 142     void onRemoteSceneCreated(RemoteScene::Ptr remoteScene, int)
 143     {
 144         pScene = remoteScene;
 145         cond.notify_all();
 146     }
 147
 148     void onRemoteSceneActionCreated(RemoteSceneAction::Ptr, int)
 149     {
 150         cond.notify_all();
 151     }
 152
 153     void onRemoteSceneExecuted(string, int)
 154     {
 155         executionSucceeded = true;
 156         cond.notify_all();
 157     }
 158 };
 159
 160 TEST_F(RemoteSceneTest, addNewRemoteScene)
 161 {
 162     if(pScene == nullptr)
 163     {
 164         pSceneCollection->addNewScene("Test Scene", std::bind(
 165             &RemoteSceneTest::onRemoteSceneCreated, this,
 166             placeholders::_1, placeholders::_2));
 167         waitForCallback();
 168     }
 169
 170     ASSERT_NE(nullptr, pScene);
 171     ASSERT_EQ("Test Scene", pScene->getName());
 172 }
 173
 174 TEST_F(RemoteSceneTest, createNewRemoteSceneWithEmptyName)
 175 {
 176     ASSERT_THROW(
 177         pSceneCollection->addNewScene("", std::bind(
 178         &RemoteSceneTest::onRemoteSceneCreated, this,
 179         placeholders::_1, placeholders::_2));, RCSInvalidParameterException);
 180 }
 181
 182 TEST_F(RemoteSceneTest, getRemoteSceneBySceneName)
 183 {
 184     if(pScene == nullptr)
 185     {
 186         pSceneCollection->addNewScene("Test Scene", std::bind(
 187             &RemoteSceneTest::onRemoteSceneCreated, this,
 188             placeholders::_1, placeholders::_2));
 189         waitForCallback();
 190     }
 191
 192     auto scene = pSceneCollection->getRemoteScene("Test Scene");
 193
 194     EXPECT_NE(nullptr, scene);
 195     EXPECT_EQ("Test Scene", scene->getName());
 196 }
 197
 198 TEST_F(RemoteSceneTest, getAllRemoteScenes)
 199 {
 200     if(pScene == nullptr)
 201     {
 202         pSceneCollection->addNewScene("Test Scene", std::bind(
 203             &RemoteSceneTest::onRemoteSceneCreated, this,
 204             placeholders::_1, placeholders::_2));
 205         waitForCallback();
 206     }
 207
 208     auto scenes = pSceneCollection->getRemoteScenes();
 209
 210     ASSERT_EQ((unsigned int)1, scenes.size());
 211     ASSERT_NE(scenes.end(), scenes.find("Test Scene"));
 212 }
 213
 214 TEST_F(RemoteSceneTest, executeRemoteScene)
 215 {
 216     createLightServer();
 217
 218     if(pSceneAction == nullptr)
 219     {
 220         pScene->addNewSceneAction(pLightResource, KEY, RCSResourceAttributes::Value(VALUE),
 221             std::bind(&RemoteSceneTest::onRemoteSceneActionCreated, this,
 222             placeholders::_1, placeholders::_2));
 223         waitForCallback();
 224     }
 225
 226     pScene->execute(std::bind(
 227         &RemoteSceneTest::onRemoteSceneExecuted, this, placeholders::_1, placeholders::_2));
 228
 229     waitForCallback();
 230
 231     ASSERT_TRUE(executionSucceeded);
 232 }