service/notification/cpp-wrapper/unittest/NSProviderServiceTest.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 <gtest/gtest.h>
  22 #include <HippoMocks/hippomocks.h>
  23 #include <atomic>
  24 #include <functional>
  25 #include <condition_variable>
  26 #include <mutex>
  27 #include <chrono>
  28
  29 #include "NSProviderService.h"
  30 #include "NSConsumerServiceSimulator.h"
  31 #include "NSUtils.h"
  32 #include "NSSyncInfo.h"
  33 #include "NSMessage.h"
  34 #include "NSMediaContents.h"
  35
  36 namespace
  37 {
  38     std::atomic_bool g_isStartedStack(false);
  39
  40     std::chrono::milliseconds g_waitForResponse(500);
  41
  42     std::condition_variable responseCon;
  43     std::mutex mutexForCondition;
  44
  45     NSConsumerSimulator g_consumerSimul;
  46     std::shared_ptr<OIC::Service::NSConsumer> g_consumer;
  47 }
  48
  49 class TestWithMock: public testing::Test
  50 {
  51     public:
  52         MockRepository mocks;
  53
  54     protected:
  55         virtual ~TestWithMock() noexcept(noexcept(std::declval<Test>().~Test()))
  56         {
  57         }
  58
  59         virtual void TearDown()
  60         {
  61             try
  62             {
  63                 mocks.VerifyAll();
  64             }
  65             catch (...)
  66             {
  67                 mocks.reset();
  68                 throw;
  69             }
  70         }
  71 };
  72
  73 class NotificationProviderServiceTest : public TestWithMock
  74 {
  75     public:
  76         NotificationProviderServiceTest() = default;
  77         ~NotificationProviderServiceTest() = default;
  78
  79         static void ConsumerSubscribedCallbackEmpty(std::shared_ptr<OIC::Service::NSConsumer> )
  80         {
  81             std::cout << __func__ << std::endl;
  82         }
  83
  84         static void MessageSynchronizedCallbackEmpty(OIC::Service::NSSyncInfo)
  85         {
  86             std::cout << __func__ << std::endl;
  87         }
  88
  89         static void MessageCallbackFromConsumerEmpty(
  90             const int &, const std::string &, const std::string &, const std::string &)
  91         {
  92             std::cout << __func__ << std::endl;
  93         }
  94
  95         static void SyncCallbackFromConsumerEmpty(int, int)
  96         {
  97             std::cout << __func__ << std::endl;
  98         }
  99
 100     protected:
 101
 102         void SetUp()
 103         {
 104             TestWithMock::SetUp();
 105
 106             if (g_isStartedStack == false)
 107             {
 108                 OC::PlatformConfig cfg
 109                 {
 110                     OC::ServiceType::InProc,
 111                     OC::ModeType::Both,
 112                     "0.0.0.0",
 113                     0,
 114                     OC::QualityOfService::HighQos
 115                 };
 116                 OC::OCPlatform::Configure(cfg);
 117
 118                 try
 119                 {
 120                     OC::OCPlatform::stopPresence();
 121                 }
 122                 catch (...)
 123                 {
 124
 125                 }
 126
 127                 g_isStartedStack = true;
 128             }
 129
 130         }
 131
 132         void TearDown()
 133         {
 134             TestWithMock::TearDown();
 135         }
 136
 137 };
 138
 139 TEST_F(NotificationProviderServiceTest, StartProviderPositiveWithPolicyTrue)
 140 {
 141     OIC::Service::NSProviderService::ProviderConfig config;
 142     config.m_subscribeRequestCb = ConsumerSubscribedCallbackEmpty;
 143     config.m_syncInfoCb = MessageSynchronizedCallbackEmpty;
 144     config.subControllability = true;
 145
 146     OIC::Service::NSResult ret =  OIC::Service::NSProviderService::getInstance()->start(config);
 147
 148     EXPECT_EQ(ret,  OIC::Service::NSResult::OK);
 149 }
 150
 151 TEST_F(NotificationProviderServiceTest, StopProviderPositive)
 152 {
 153     OIC::Service::NSResult ret =  OIC::Service::NSProviderService::getInstance()->stop();
 154
 155     EXPECT_EQ(ret,  OIC::Service::NSResult::OK);
 156 }
 157
 158 TEST_F(NotificationProviderServiceTest, StartProviderPositiveWithPolicyFalse)
 159 {
 160     OIC::Service::NSProviderService::ProviderConfig  config;
 161     config.m_subscribeRequestCb = ConsumerSubscribedCallbackEmpty;
 162     config.m_syncInfoCb = MessageSynchronizedCallbackEmpty;
 163     config.subControllability = false;
 164
 165     OIC::Service::NSResult ret =  OIC::Service::NSProviderService::getInstance()->start(config);
 166
 167     EXPECT_EQ(ret,  OIC::Service::NSResult::OK);
 168     OIC::Service::NSProviderService::getInstance()->stop();
 169 }
 170
 171 TEST_F(NotificationProviderServiceTest,
 172        ExpectCallbackWhenReceiveSubscribeRequestWithAccepterProvider)
 173 {
 174     g_consumer = NULL;
 175     mocks.ExpectCallFunc(ConsumerSubscribedCallbackEmpty).Do(
 176         []( std::shared_ptr<OIC::Service::NSConsumer> consumer)
 177     {
 178         std::cout << "ConsumerSubscribedCallbackEmpty" << std::endl;
 179         g_consumer = consumer;
 180         responseCon.notify_all();
 181     });
 182
 183     OIC::Service::NSProviderService::ProviderConfig  config;
 184     config.m_subscribeRequestCb = ConsumerSubscribedCallbackEmpty;
 185     config.m_syncInfoCb = MessageSynchronizedCallbackEmpty;
 186     config.subControllability = true;
 187
 188     OIC::Service::NSProviderService::getInstance()->start(config);
 189
 190     {
 191         std::unique_lock< std::mutex > lock { mutexForCondition };
 192         responseCon.wait_for(lock, g_waitForResponse);
 193     }
 194
 195     g_consumerSimul.setCallback(MessageCallbackFromConsumerEmpty,
 196                                 SyncCallbackFromConsumerEmpty);
 197     g_consumerSimul.findProvider();
 198
 199     std::unique_lock< std::mutex > lock { mutexForCondition };
 200     responseCon.wait_for(lock, g_waitForResponse);
 201
 202     ASSERT_NE(nullptr, g_consumer) << "error: discovery failure";
 203 }
 204
 205 TEST_F(NotificationProviderServiceTest, NeverCallNotifyOnConsumerByAcceptIsFalse)
 206 {
 207     bool expectTrue = true;
 208     int msgID = 0;
 209
 210     mocks.OnCallFunc(MessageCallbackFromConsumerEmpty).Do(
 211         [& expectTrue, &msgID](const int &id, const std::string &, const std::string &,
 212                                const std::string &)
 213     {
 214         if (id == msgID)
 215         {
 216             std::cout << "This function never call" << std::endl;
 217             expectTrue = false;
 218         }
 219         responseCon.notify_all();
 220     });
 221
 222     ASSERT_NE(nullptr, g_consumer) << "error: discovery failure";
 223
 224     g_consumer->acceptSubscription(false);
 225     OIC::Service::NSMessage msg =  OIC::Service::NSProviderService::getInstance()->createMessage();
 226     msgID = (int)msg.getMessageId();
 227     msg.setTitle(std::string("Title"));
 228     msg.setContentText(std::string("ContentText"));
 229     msg.setSourceName(std::string("OCF"));
 230
 231     OIC::Service::NSProviderService::getInstance()->sendMessage(msg);
 232     {
 233         std::unique_lock< std::mutex > lock { mutexForCondition };
 234         responseCon.wait_for(lock, g_waitForResponse);
 235     }
 236
 237     std::unique_lock< std::mutex > lock { mutexForCondition };
 238     responseCon.wait_for(lock, g_waitForResponse);
 239
 240     EXPECT_EQ(expectTrue, true);
 241 }
 242
 243 TEST_F(NotificationProviderServiceTest, ExpectCallNotifyOnConsumerByAcceptIsTrue)
 244 {
 245     int msgID = 0;
 246
 247     ASSERT_NE(nullptr, g_consumer) << "error: discovery failure";
 248
 249     mocks.ExpectCallFunc(MessageCallbackFromConsumerEmpty).Do(
 250         [&msgID](const int &id, const std::string &, const std::string &, const std::string &)
 251     {
 252         if (id == msgID)
 253         {
 254             std::cout << "ExpectCallNotifyOnConsumerByAcceptIsTrue" << std::endl;
 255             responseCon.notify_all();
 256         }
 257     });
 258
 259     g_consumer->acceptSubscription(true);
 260
 261     OIC::Service::NSMessage msg =  OIC::Service::NSProviderService::getInstance()->createMessage();
 262     msgID = (int)msg.getMessageId();
 263     msg.setTitle(std::string("Title"));
 264     msg.setContentText(std::string("ContentText"));
 265     msg.setSourceName(std::string("OCF"));
 266
 267     OIC::Service::NSProviderService::getInstance()->sendMessage(msg);
 268     std::unique_lock< std::mutex > lock { mutexForCondition };
 269     responseCon.wait_for(lock, g_waitForResponse);
 270
 271 }
 272
 273 TEST_F(NotificationProviderServiceTest, ExpectCallbackSyncOnReadToConsumer)
 274 {
 275     int id = 0;
 276
 277     mocks.ExpectCallFunc(SyncCallbackFromConsumerEmpty).Do(
 278         [& id](int &type, int &syncId)
 279     {
 280         std::cout << "MessageSynchronizedCallbackEmpty" << std::endl;
 281         if (syncId == id &&
 282             type == (int)OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ)
 283         {
 284             std::cout << "ExpectCallbackSyncOnReadFromConsumer" << std::endl;
 285             responseCon.notify_all();
 286         }
 287     });
 288
 289     OIC::Service::NSMessage msg =  OIC::Service::NSProviderService::getInstance()->createMessage();
 290     id = (int)msg.getMessageId();
 291     msg.setTitle(std::string("Title"));
 292     msg.setContentText(std::string("ContentText"));
 293     msg.setSourceName(std::string("OCF"));
 294
 295     OIC::Service::NSProviderService::getInstance()->sendSyncInfo(msg.getMessageId(),
 296             OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ);
 297     std::unique_lock< std::mutex > lock { mutexForCondition };
 298     responseCon.wait_for(lock, g_waitForResponse);
 299 }
 300
 301 TEST_F(NotificationProviderServiceTest, ExpectCallbackSyncOnReadFromConsumer)
 302 {
 303     int type = (int)OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ;
 304     int id = 0;
 305     mocks.ExpectCallFunc(MessageSynchronizedCallbackEmpty).Do(
 306         [& id](OIC::Service::NSSyncInfo sync)
 307     {
 308         std::cout << "MessageSynchronizedCallbackEmpty" << std::endl;
 309         if ((int)sync.getMessageId() == id
 310             && sync.getState() == OIC::Service::NSSyncInfo::NSSyncType::NS_SYNC_READ)
 311         {
 312             std::cout << "ExpectCallbackSyncOnReadFromConsumer" << std::endl;
 313             responseCon.notify_all();
 314         }
 315     });
 316
 317     OIC::Service::NSMessage msg =  OIC::Service::NSProviderService::getInstance()->createMessage();
 318     id = (int)msg.getMessageId();
 319     msg.setTitle(std::string("Title"));
 320     msg.setContentText(std::string("ContentText"));
 321     msg.setSourceName(std::string("OCF"));
 322     g_consumerSimul.syncToProvider(type, id, msg.getProviderId());
 323     std::unique_lock< std::mutex > lock { mutexForCondition };
 324     responseCon.wait(lock);
 325 }
 326
 327 TEST_F(NotificationProviderServiceTest, ExpectEqualAddedTopicsAndRegisteredTopics)
 328 {
 329     std::string str1("TEST1");
 330     std::string str2("TEST2");
 331     OIC::Service::NSProviderService::getInstance()->registerTopic(str1);
 332     OIC::Service::NSProviderService::getInstance()->registerTopic(str2);
 333     std::unique_lock< std::mutex > lock { mutexForCondition };
 334     responseCon.wait_for(lock, g_waitForResponse);
 335     bool isSame = false;
 336     auto topicList =
 337         OIC::Service::NSProviderService::getInstance()->getRegisteredTopicList();
 338     if (!topicList)
 339     {
 340         printf("topic is NULL\n");
 341         isSame = false;
 342     }
 343     else
 344     {
 345         std::string compString[10];
 346         int i = 0;
 347         for (auto itr : topicList->getTopicsList())
 348         {
 349             compString[i] = itr.getTopicName(); i++;
 350         }
 351         std::cout << compString[0] << std::endl;
 352         std::cout << compString[1] << std::endl;
 353         if (str1.compare(compString[0]) == 0 && str2.compare(compString[1]) == 0)
 354         {
 355             isSame = true;
 356         }
 357     }
 358     EXPECT_EQ(isSame, true);
 359
 360     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str1);
 361     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str2);
 362     responseCon.wait_for(lock, g_waitForResponse);
 363 }
 364
 365 TEST_F(NotificationProviderServiceTest, ExpectEqualUnregisteredTopicsAndRegisteredTopics)
 366 {
 367     std::string str1("TEST1");
 368     std::string str2("TEST2");
 369     OIC::Service::NSProviderService::getInstance()->registerTopic(str1);
 370     OIC::Service::NSProviderService::getInstance()->registerTopic(str2);
 371     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str2);
 372     std::unique_lock< std::mutex > lock { mutexForCondition };
 373     responseCon.wait_for(lock, g_waitForResponse);
 374     bool isSame = false;
 375     auto topicList =
 376         OIC::Service::NSProviderService::getInstance()->getRegisteredTopicList();
 377     if (!topicList)
 378     {
 379         printf("topic is NULL\n");
 380         isSame = false;
 381     }
 382     else
 383     {
 384         auto topic = topicList->getTopicsList();
 385         auto it = topic.begin();
 386         std::string compStr = (*it).getTopicName() ;
 387         std::cout << compStr << std::endl;
 388         if (str1.compare(compStr) == 0 )
 389         {
 390             isSame = true;
 391         }
 392     }
 393     EXPECT_EQ(isSame, true);
 394
 395     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str1);
 396     responseCon.wait_for(lock, g_waitForResponse);
 397 }
 398
 399 TEST_F(NotificationProviderServiceTest, ExpectEqualSetConsumerTopicsAndGetConsumerTopics)
 400 {
 401     std::string str1("TEST1");
 402     std::string str2("TEST2");
 403     OIC::Service::NSProviderService::getInstance()->registerTopic(str1);
 404     OIC::Service::NSProviderService::getInstance()->registerTopic(str2);
 405
 406     ASSERT_NE(nullptr, g_consumer) << "error: discovery failure";
 407
 408     g_consumer->setTopic(str1);
 409
 410     std::unique_lock< std::mutex > lock { mutexForCondition };
 411     responseCon.wait_for(lock, g_waitForResponse);
 412
 413     bool isSame = false;
 414     auto topicList =  g_consumer->getConsumerTopicList();
 415
 416     if (!topicList)
 417     {
 418         printf("topic is NULL\n");
 419         isSame = false;
 420     }
 421     else
 422     {
 423         std::string compString[10];
 424         int i = 0, state[10] = {0};
 425         for (auto itr : topicList->getTopicsList())
 426         {
 427             compString[i] = itr.getTopicName();
 428             state[i++] = (int) itr.getState();
 429         }
 430         std::cout << compString[0] << std::endl;
 431         std::cout << compString[1] << std::endl;
 432         if (str1.compare(compString[0]) == 0 && str2.compare(compString[1]) == 0
 433             && state[0] == 1 &&  state[1] == 0)
 434         {
 435             isSame = true;
 436         }
 437     }
 438
 439     EXPECT_EQ(isSame, true);
 440
 441     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str1);
 442     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str2);
 443     responseCon.wait_for(lock, g_waitForResponse);
 444 }
 445
 446 TEST_F(NotificationProviderServiceTest, ExpectEqualUnSetConsumerTopicsAndGetConsumerTopics)
 447 {
 448     std::string str1("TEST1");
 449     std::string str2("TEST2");
 450     OIC::Service::NSProviderService::getInstance()->registerTopic(str1);
 451     OIC::Service::NSProviderService::getInstance()->registerTopic(str2);
 452
 453     ASSERT_NE(nullptr, g_consumer) << "error: discovery failure";
 454
 455     g_consumer->setTopic(str1);
 456     g_consumer->setTopic(str2);
 457     g_consumer->unsetTopic(str1);
 458
 459     std::unique_lock< std::mutex > lock { mutexForCondition };
 460     responseCon.wait_for(lock, g_waitForResponse);
 461
 462     bool isSame = false;
 463     auto topicList =  g_consumer->getConsumerTopicList();
 464
 465     if (!topicList)
 466     {
 467         printf("topic is NULL\n");
 468         isSame = false;
 469     }
 470     else
 471     {
 472         std::string compString[10];
 473         int i = 0, state[10] = {0};
 474         for (auto itr : topicList->getTopicsList())
 475         {
 476             compString[i] = itr.getTopicName();
 477             state[i++] = (int) itr.getState();
 478         }
 479         std::cout << compString[0] << std::endl;
 480         std::cout << compString[1] << std::endl;
 481         if (str1.compare(compString[0]) == 0 && str2.compare(compString[1]) == 0
 482             && state[0] == 0 &&  state[1] == 1)
 483         {
 484             isSame = true;
 485         }
 486     }
 487
 488     EXPECT_EQ(isSame, true);
 489
 490     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str1);
 491     OIC::Service::NSProviderService::getInstance()->unregisterTopic(str2);
 492     responseCon.wait_for(lock, g_waitForResponse);
 493 }
 494
 495
 496 TEST_F(NotificationProviderServiceTest, CancelObserves)
 497 {
 498     bool ret = g_consumerSimul.cancelObserves();
 499
 500     std::unique_lock< std::mutex > lock { mutexForCondition };
 501     responseCon.wait_for(lock, g_waitForResponse);
 502
 503     EXPECT_EQ(ret, true);
 504 }