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 >(), [](PrimitiveResource*){});
  63         cb = ([](BROKER_STATE)->OCStackResult{return OC_STACK_OK;});
  64         id = 0;
  65     }
  66
  67     void TearDown()
  68     {
  69         TestWithMock::TearDown();
  70         instance.reset();
  71         pResource.reset();
  72         id = 0;
  73         cb = nullptr;
  74     }
  75
  76     void MockingFunc()
  77     {
  78         mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do([](GetCallback){});
  79         mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return(std::string());
  80         mocks.OnCallFuncOverload(static_cast< subscribePresenceSig1 >(OC::OCPlatform::subscribePresence)).Return(OC_STACK_OK);
  81     }
  82
  83 };
  84 TEST_F(ResourcePresenceTest,timeoutCB_TimeOverWhenIsRequestGet)
  85 {
  86     MockingFunc();
  87     instance->initializeResourcePresence(pResource);
  88     std::cout<<"wait while done timeout requestGet\n";
  89     BROKER_STATE state;
  90     state = instance->getResourceState();
  91     sleep((BROKER_DEVICE_PRESENCE_TIMEROUT/1000)+1);
  92     ASSERT_EQ(state,instance->getResourceState());
  93 }
  94
  95 TEST_F(ResourcePresenceTest,initializeResourcePresence_NormalhandlingIfNormalResource)
  96 {
  97     MockingFunc();
  98     instance->initializeResourcePresence(pResource);
  99     ASSERT_NE(nullptr,instance->getPrimitiveResource());
 100 }
 101
 102 TEST_F(ResourcePresenceTest,addBrokerRequester_ReturnNormalValueIfNormalParams)
 103 {
 104     MockingFunc();
 105     instance->initializeResourcePresence(pResource);
 106     id = 1;
 107     instance->addBrokerRequester(id,cb);
 108     EXPECT_FALSE(instance->isEmptyRequester());
 109
 110 }
 111
 112 TEST_F(ResourcePresenceTest,removeBrokerRequester_NormalHandlingIfNormalId)
 113 {
 114
 115     MockingFunc();
 116
 117     instance->initializeResourcePresence(pResource);
 118     id = 1;
 119     instance->addBrokerRequester(id,cb);
 120     id = 2;
 121     instance->addBrokerRequester(id,cb);
 122
 123     instance->removeBrokerRequester(id);
 124     ASSERT_EQ(1,instance->requesterListSize());
 125
 126 }
 127
 128 TEST_F(ResourcePresenceTest,removeAllBrokerRequester_NormalHandling)
 129 {
 130
 131     MockingFunc();
 132
 133     instance->initializeResourcePresence(pResource);
 134     id = 1;
 135     instance->addBrokerRequester(id,cb);
 136     id = 2;
 137     instance->addBrokerRequester(id,cb);
 138
 139     instance->removeAllBrokerRequester();
 140     ASSERT_TRUE(instance->isEmptyRequester());
 141
 142 }
 143
 144 TEST_F(ResourcePresenceTest,removeAllBrokerRequester_ErrorHandlingIfListNull)
 145 {
 146     MockingFunc();
 147
 148     instance->initializeResourcePresence(pResource);
 149     instance->removeAllBrokerRequester();
 150
 151 }
 152
 153 TEST_F(ResourcePresenceTest,requestResourceState_NormalHandling)
 154 {
 155
 156     MockingFunc();
 157
 158     instance->initializeResourcePresence(pResource);
 159
 160     ASSERT_NO_THROW(instance->requestResourceState());
 161
 162 }
 163
 164 TEST_F(ResourcePresenceTest,changePresenceMode_NormalHandlingIfNewModeDifferent)
 165 {
 166
 167     MockingFunc();
 168
 169     instance->initializeResourcePresence(pResource);
 170
 171     instance->changePresenceMode(BROKER_MODE::DEVICE_PRESENCE_MODE);
 172
 173 }
 174
 175 TEST_F(ResourcePresenceTest,getResourceState_NormalHandling)
 176 {
 177     MockingFunc();
 178     instance->initializeResourcePresence(pResource);
 179     ASSERT_EQ(BROKER_STATE::REQUESTED,instance->getResourceState());
 180
 181 }
 182
 183 TEST_F(ResourcePresenceTest,changePresenceMode_NormalHandlingIfNewModeSame)
 184 {
 185
 186     MockingFunc();
 187
 188     instance->initializeResourcePresence(pResource);
 189
 190     instance->changePresenceMode(BROKER_MODE::NON_PRESENCE_MODE);
 191
 192 }
 193
 194 TEST_F(ResourcePresenceTest,getPrimitiveResource_NormalHandling)
 195 {
 196
 197     MockingFunc();
 198
 199     instance->initializeResourcePresence(pResource);
 200     ASSERT_NE(nullptr,instance->getPrimitiveResource());
 201
 202 }
 203
 204 TEST_F(ResourcePresenceTest,isEmptyRequester_NormalHandling)
 205 {
 206
 207     MockingFunc();
 208
 209     instance->initializeResourcePresence(pResource);
 210     id = 1;
 211     instance->addBrokerRequester(id,cb);
 212     instance->removeAllBrokerRequester();
 213     ASSERT_TRUE(instance->isEmptyRequester());
 214
 215 }
 216
 217 TEST_F(ResourcePresenceTest,getCB_NormalHandlingIfMessageOC_STACK_OK)
 218 {
 219
 220     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet).Do(
 221                 [](GetCallback callback){
 222
 223         OIC::Service::HeaderOptions op;
 224         RCSResourceAttributes attr;
 225         OIC::Service::ResponseStatement res(attr);
 226
 227         callback(op,res,OC_STACK_OK);
 228
 229     });
 230
 231     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
 232                                 [](GetCallback){
 233         std::cout <<"End call requestGetFunc()\n";
 234                     });
 235     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("address1");
 236
 237     mocks.OnCallFuncOverload(static_cast< subscribePresenceSig1 >(OC::OCPlatform::subscribePresence)).Do(
 238             [](OC::OCPlatform::OCPresenceHandle&,
 239                     const std::string&, OCConnectivityType, SubscribeCallback callback)->OCStackResult{
 240
 241         callback(OC_STACK_OK,0,std::string());
 242         return OC_STACK_OK;
 243
 244     }).Return(OC_STACK_OK);
 245
 246     instance->initializeResourcePresence(pResource);
 247     sleep(3);
 248
 249 }
 250
 251
 252