service/resource-encapsulation/src/resourceBroker/unittest/ResourcePresenceUnitTest.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 #include <iostream>
  21 #include <vector>
  22 #include <unistd.h>
  23 #include <memory>
  24
  25 #include "gtest/gtest.h"
  26 #include "HippoMocks/hippomocks.h"
  27
  28 #include "OCResource.h"
  29 #include "OCPlatform.h"
  30
  31 #include "PrimitiveResource.h"
  32 #include "BrokerTypes.h"
  33 #include "ResponseStatement.h"
  34 #include "RCSResourceAttributes.h"
  35 #include "ResourcePresence.h"
  36 #include "UnitTestHelper.h"
  37
  38 using namespace testing;
  39 using namespace OIC::Service;
  40 using namespace OC;
  41
  42 typedef OCStackResult (*subscribePresenceSig1)(OC::OCPlatform::OCPresenceHandle&,
  43         const std::string&, OCConnectivityType, SubscribeCallback);
  44
  45 class ResourcePresenceTest : public TestWithMock
  46 {
  47 public:
  48
  49     typedef std::function<void(const HeaderOptions&, const ResponseStatement&, int)> GetCallback;
  50
  51     std::shared_ptr<ResourcePresence> instance;
  52     PrimitiveResource::Ptr pResource;
  53     BrokerCB cb;
  54     BrokerID id;
  55
  56 protected:
  57
  58     void SetUp()
  59     {
  60         TestWithMock::SetUp();
  61         instance.reset(new ResourcePresence());
  62         pResource = PrimitiveResource::Ptr(mocks.Mock< PrimitiveResource >(),
  63                                            [](PrimitiveResource*)
  64                                            {
  65
  66                                            });
  67         cb = ([](BROKER_STATE)->OCStackResult
  68                 {
  69                     return OC_STACK_OK;
  70                 });
  71         id = 0;
  72     }
  73
  74     void TearDown()
  75     {
  76         TestWithMock::TearDown();
  77         instance.reset();
  78         pResource.reset();
  79         id = 0;
  80         cb = nullptr;
  81     }
  82
  83     void MockingFunc()
  84     {
  85         mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
  86                 [](GetCallback)
  87                 {
  88
  89                 });
  90         mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return(std::string());
  91         mocks.OnCallFuncOverload(static_cast< subscribePresenceSig1 >(OC::OCPlatform::subscribePresence)).Return(OC_STACK_OK);
  92     }
  93
  94 };
  95 TEST_F(ResourcePresenceTest,timeoutCB_TimeOverWhenIsRequestGet)
  96 {
  97     MockingFunc();
  98     instance->initializeResourcePresence(pResource);
  99     std::cout<<"wait while done timeout requestGet\n";
 100     BROKER_STATE state = BROKER_STATE::NONE;
 101     state = instance->getResourceState();
 102     sleep((BROKER_DEVICE_PRESENCE_TIMEROUT/1000)+1);
 103     ASSERT_EQ(state,instance->getResourceState());
 104 }
 105
 106 TEST_F(ResourcePresenceTest,initializeResourcePresence_NormalhandlingIfNormalResource)
 107 {
 108     MockingFunc();
 109     instance->initializeResourcePresence(pResource);
 110     ASSERT_NE(nullptr,instance->getPrimitiveResource());
 111 }
 112
 113 TEST_F(ResourcePresenceTest,addBrokerRequester_ReturnNormalValueIfNormalParams)
 114 {
 115     MockingFunc();
 116     instance->initializeResourcePresence(pResource);
 117     id = 1;
 118     instance->addBrokerRequester(id,cb);
 119     EXPECT_FALSE(instance->isEmptyRequester());
 120
 121 }
 122
 123 TEST_F(ResourcePresenceTest,removeBrokerRequester_NormalHandlingIfNormalId)
 124 {
 125
 126     MockingFunc();
 127
 128     instance->initializeResourcePresence(pResource);
 129     id = 1;
 130     instance->addBrokerRequester(id,cb);
 131     id = 2;
 132     instance->addBrokerRequester(id,cb);
 133
 134     instance->removeBrokerRequester(id);
 135     ASSERT_EQ(1,instance->requesterListSize());
 136
 137 }
 138
 139 TEST_F(ResourcePresenceTest,removeAllBrokerRequester_NormalHandling)
 140 {
 141
 142     MockingFunc();
 143
 144     instance->initializeResourcePresence(pResource);
 145     id = 1;
 146     instance->addBrokerRequester(id,cb);
 147     id = 2;
 148     instance->addBrokerRequester(id,cb);
 149
 150     instance->removeAllBrokerRequester();
 151     ASSERT_TRUE(instance->isEmptyRequester());
 152
 153 }
 154
 155 TEST_F(ResourcePresenceTest,removeAllBrokerRequester_ErrorHandlingIfListNull)
 156 {
 157     MockingFunc();
 158
 159     instance->initializeResourcePresence(pResource);
 160     instance->removeAllBrokerRequester();
 161
 162 }
 163
 164 TEST_F(ResourcePresenceTest,requestResourceState_NormalHandling)
 165 {
 166
 167     MockingFunc();
 168
 169     instance->initializeResourcePresence(pResource);
 170
 171     ASSERT_NO_THROW(instance->requestResourceState());
 172
 173 }
 174
 175 TEST_F(ResourcePresenceTest,changePresenceMode_NormalHandlingIfNewModeDifferent)
 176 {
 177
 178     MockingFunc();
 179
 180     instance->initializeResourcePresence(pResource);
 181
 182     instance->changePresenceMode(BROKER_MODE::DEVICE_PRESENCE_MODE);
 183
 184 }
 185
 186 TEST_F(ResourcePresenceTest,getResourceState_NormalHandling)
 187 {
 188     MockingFunc();
 189     instance->initializeResourcePresence(pResource);
 190     ASSERT_EQ(BROKER_STATE::REQUESTED,instance->getResourceState());
 191
 192 }
 193
 194 TEST_F(ResourcePresenceTest,changePresenceMode_NormalHandlingIfNewModeSame)
 195 {
 196
 197     MockingFunc();
 198
 199     instance->initializeResourcePresence(pResource);
 200
 201     instance->changePresenceMode(BROKER_MODE::NON_PRESENCE_MODE);
 202
 203 }
 204
 205 TEST_F(ResourcePresenceTest,getPrimitiveResource_NormalHandling)
 206 {
 207
 208     MockingFunc();
 209
 210     instance->initializeResourcePresence(pResource);
 211     ASSERT_NE(nullptr,instance->getPrimitiveResource());
 212
 213 }
 214
 215 TEST_F(ResourcePresenceTest,isEmptyRequester_NormalHandling)
 216 {
 217
 218     MockingFunc();
 219
 220     instance->initializeResourcePresence(pResource);
 221     id = 1;
 222     instance->addBrokerRequester(id,cb);
 223     instance->removeAllBrokerRequester();
 224     ASSERT_TRUE(instance->isEmptyRequester());
 225
 226 }
 227
 228 TEST_F(ResourcePresenceTest,getCB_NormalHandlingIfMessageOC_STACK_OK)
 229 {
 230
 231     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet).Do(
 232                 [](GetCallback callback)
 233                 {
 234                     OIC::Service::HeaderOptions op;
 235                     RCSResourceAttributes attr;
 236                     OIC::Service::ResponseStatement res(attr);
 237
 238                     callback(op,res,OC_STACK_OK);
 239
 240                 });
 241
 242     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
 243                 [](GetCallback)
 244                 {
 245                     std::cout <<"End call requestGetFunc()\n";
 246                 });
 247     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("address1");
 248
 249     mocks.OnCallFuncOverload(static_cast< subscribePresenceSig1 >(OC::OCPlatform::subscribePresence)).Do(
 250             [](OC::OCPlatform::OCPresenceHandle&,
 251                     const std::string&, OCConnectivityType, SubscribeCallback callback)->OCStackResult
 252                 {
 253                     callback(OC_STACK_OK,0,std::string());
 254                     return OC_STACK_OK;
 255
 256                 }
 257     ).Return(OC_STACK_OK);
 258
 259     instance->initializeResourcePresence(pResource);
 260     sleep(3);
 261
 262 }
 263
 264
 265