service/notification/unittest/NSProviderTest2.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2017 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 <iostream>
  23 #include <condition_variable>
  24 #include <mutex>
  25 #include <chrono>
  26
  27 #include "OCPlatform.h"
  28 #include "ocpayload.h"
  29
  30 #include "NSCommon.h"
  31 #include "NSConstants.h"
  32 #include "NSProviderInterface.h"
  33
  34 #include "NSProviderListener.h"
  35 #include "NSUnittestUtil.h"
  36
  37 namespace
  38 {
  39     std::chrono::milliseconds g_waitForResponse(1000);
  40
  41     std::condition_variable responseProviderSub;
  42     std::mutex responseProviderSubLock;
  43
  44     std::condition_variable responseProviderSync;
  45     std::mutex responseProviderSyncLock;
  46
  47     char * g_consumerID = NULL;
  48     int expectedMsgId;
  49     int expectedSyncType = NS_SYNC_READ;
  50
  51     const std::string testConsumerId = "123456789012345678901234567890123457";
  52
  53     static FILE* server_open(const char * path, const char * mode)
  54     {
  55         if (0 == strcmp(path, OC_SECURITY_DB_DAT_FILE_NAME))
  56         {
  57             std::string file_name = "./oic_svr_db_ns.dat";
  58 #ifndef LOCAL_RUNNING
  59             file_name = "./service/notification/unittest/oic_svr_db_ns.dat";
  60 #endif
  61             return fopen(file_name.c_str(), mode);
  62         }
  63         else
  64         {
  65             return fopen(path, mode);
  66         }
  67     }
  68
  69     static void NSRequestedSubscribeCallback(NSConsumer * consumer)
  70     {
  71         if (g_consumerID)
  72         {
  73             free(g_consumerID);
  74         }
  75         g_consumerID = strdup(consumer->consumerId);
  76
  77         responseProviderSub.notify_all();
  78     }
  79
  80     static void NSSyncCallback(NSSyncInfo * sync)
  81     {
  82         expectedSyncType = sync->state;
  83         expectedMsgId = sync->messageId;
  84         free(sync);
  85         responseProviderSync.notify_all();
  86     }
  87
  88     OCEntityHandlerRequest * getEntityRequest(OCMethod method, OCObserveAction action)
  89     {
  90         static OCObservationId id = 10;
  91         OCEntityHandlerRequest * request =
  92                 (OCEntityHandlerRequest *)malloc(sizeof(OCEntityHandlerRequest));
  93         EXPECT_NE((void *)NULL, request);
  94         request->requestHandle = NULL;
  95         request->resource = NULL;
  96
  97         if (OC_REST_OBSERVE == method)
  98         {
  99             request->obsInfo.action = action;
 100             request->obsInfo.obsId = id++;
 101
 102             std::string query = std::string(NS_QUERY_CONSUMER_ID)
 103                     + "=" + testConsumerId;
 104             request->query = (char *)malloc(query.size() + 1);
 105             EXPECT_NE((void *)NULL, request->query);
 106             strncpy(request->query, query.c_str(), query.size() + 1);
 107         }
 108         request->method = method;
 109         request->numRcvdVendorSpecificHeaderOptions = 0;
 110         request->payload = NULL;
 111
 112         return request;
 113     }
 114
 115     OCEntityHandlerRequest * getPostSyncEntityRequest(uint64_t id)
 116     {
 117         OCEntityHandlerRequest * request =
 118                 (OCEntityHandlerRequest *)malloc(sizeof(OCEntityHandlerRequest));
 119         EXPECT_NE((void *)NULL, request);
 120         request->requestHandle = NULL;
 121         request->resource = NULL;
 122
 123         request->method = OC_REST_POST;
 124         request->numRcvdVendorSpecificHeaderOptions = 0;
 125         request->query = NULL;
 126
 127         OCRepPayload * payload = OCRepPayloadCreate();
 128         EXPECT_NE((void *)NULL, payload);
 129
 130         bool ret = OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, id);
 131         OCUUIdentity provider;
 132         OC::OCPlatform::getDeviceId(&provider);
 133         ret &= OCRepPayloadSetPropString(payload,
 134                      NS_ATTRIBUTE_PROVIDER_ID, (const char *)provider.id);
 135         ret &= OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_STATE, NS_SYNC_READ);
 136         EXPECT_EQ(true, ret);
 137
 138         request->payload = (OCPayload *) payload;
 139
 140         return request;
 141     }
 142
 143     void stackInit()
 144     {
 145         static OCPersistentStorage gps {server_open, fread, fwrite, fclose, unlink };
 146
 147         OC::PlatformConfig cfg
 148         {
 149             OC::ServiceType::InProc,
 150             OC::ModeType::Both,
 151             "0.0.0.0",
 152             0,
 153             OC::QualityOfService::HighQos,
 154             &gps
 155         };
 156         OC::OCPlatform::Configure(cfg);
 157
 158         try
 159         {
 160             OC::OCPlatform::stopPresence();
 161         }
 162         catch (...)
 163         {
 164
 165         }
 166     }
 167 }
 168
 169 TEST(NotificationProviderTest, StartProviderPositiveWithNSPolicyTrue)
 170 {
 171     stackInit();
 172
 173     NSProviderConfig config;
 174     config.subRequestCallback = NSRequestedSubscribeCallback;
 175     config.syncInfoCallback = NSSyncCallback;
 176     config.subControllability = true;
 177     config.userInfo = strdup("user1");
 178     config.resourceSecurity = false;
 179
 180     NSResult ret = NSStartProvider(config);
 181
 182     EXPECT_EQ(ret, NS_OK);
 183     free(config.userInfo);
 184     config.userInfo = NULL;
 185 }
 186
 187 TEST(NotificationProviderTest, StopProviderPositive)
 188 {
 189     NSResult ret = NSStopProvider();
 190
 191     EXPECT_EQ(ret, NS_OK);
 192 }
 193
 194 TEST(NotificationProviderTest, ExpectCallbackSubscribeRequestWithAccepterProvider)
 195 {
 196     NSProviderConfig config;
 197     config.subRequestCallback = NSRequestedSubscribeCallback;
 198     config.syncInfoCallback = NSSyncCallback;
 199     config.subControllability = true;
 200     config.userInfo = NULL;
 201     config.resourceSecurity = false;
 202
 203     NSStartProvider(config);
 204
 205     OCEntityHandlerFlag flag = OC_OBSERVE_FLAG;
 206     OCEntityHandlerRequest * msgRequest = getEntityRequest(OC_REST_OBSERVE, OC_OBSERVE_REGISTER);
 207     NSEntityHandlerMessageCb(flag, msgRequest, NULL);
 208     {
 209         std::unique_lock< std::mutex > lock{ responseProviderSubLock };
 210         responseProviderSub.wait_for(lock, g_waitForResponse);
 211     }
 212     free(msgRequest->query);
 213     free(msgRequest);
 214
 215     OCEntityHandlerRequest * syncRequest = getEntityRequest(OC_REST_OBSERVE, OC_OBSERVE_REGISTER);
 216     NSEntityHandlerSyncCb(flag, syncRequest, NULL);
 217     {
 218         std::unique_lock< std::mutex > lock{ responseProviderSubLock };
 219         responseProviderSub.wait_for(lock, g_waitForResponse);
 220     }
 221
 222     free(syncRequest->query);
 223     free(syncRequest);
 224
 225     EXPECT_NE((void *)NULL, g_consumerID);
 226 }
 227
 228 TEST(NotificationProviderTest, ExpectSuccessSendAllow)
 229 {
 230     auto ret = NSAcceptSubscription(g_consumerID, true);
 231     EXPECT_EQ(NS_OK, ret);
 232 }
 233
 234 TEST(NotificationProviderTest, ExpectFailGetRequestForNotificationWithInvalidInterface)
 235 {
 236     OCEntityHandlerFlag flag = OC_REQUEST_FLAG;
 237     OCEntityHandlerRequest * getRequest = getEntityRequest(OC_REST_GET, OC_OBSERVE_NO_OPTION);
 238     std::string query = std::string("if=") + "test.invalid";
 239     getRequest->query = strdup(query.c_str());
 240     auto ret = NSEntityHandlerNotificationCb(flag, getRequest, NULL);
 241
 242     EXPECT_NE(ret, OC_EH_OK);
 243
 244     free(getRequest->query);
 245     free(getRequest);
 246 }
 247
 248 TEST(NotificationProviderTest, ExpectFailGetRequestForMsgWithInvalidInterface)
 249 {
 250     OCEntityHandlerFlag flag = OC_REQUEST_FLAG;
 251     OCEntityHandlerRequest * getRequest = getEntityRequest(OC_REST_GET, OC_OBSERVE_NO_OPTION);
 252     std::string query = std::string("if=") + "test.invalid";
 253     getRequest->query = strdup(query.c_str());
 254     auto ret = NSEntityHandlerMessageCb(flag, getRequest, NULL);
 255
 256     EXPECT_NE(ret, OC_EH_OK);
 257
 258     free(getRequest->query);
 259     free(getRequest);
 260 }
 261
 262 TEST(NotificationProviderTest, ExpectFailGetRequestForSyncWithInvalidInterface)
 263 {
 264     OCEntityHandlerFlag flag = OC_REQUEST_FLAG;
 265     OCEntityHandlerRequest * getRequest = getEntityRequest(OC_REST_GET, OC_OBSERVE_NO_OPTION);
 266     std::string query = std::string("if=") + "test.invalid";
 267     getRequest->query = strdup(query.c_str());
 268     auto ret = NSEntityHandlerSyncCb(flag, getRequest, NULL);
 269
 270     EXPECT_NE(ret, OC_EH_OK);
 271
 272     free(getRequest->query);
 273     free(getRequest);
 274 }
 275
 276 TEST(NotificationProviderTest, ExpectFailGetRequestForTopicWithInvalidInterface)
 277 {
 278     OCEntityHandlerFlag flag = OC_REQUEST_FLAG;
 279     OCEntityHandlerRequest * getRequest = getEntityRequest(OC_REST_GET, OC_OBSERVE_NO_OPTION);
 280     std::string query = std::string("if=") + "test.invalid";
 281     getRequest->query = strdup(query.c_str());
 282     auto ret = NSEntityHandlerTopicCb(flag, getRequest, NULL);
 283
 284     EXPECT_NE(ret, OC_EH_OK);
 285
 286     free(getRequest->query);
 287     free(getRequest);
 288 }
 289
 290 TEST(NotificationProviderTest, ExpectSuccessGetRequestForTopicWithInvalidInterface)
 291 {
 292     OCEntityHandlerFlag flag = OC_REQUEST_FLAG;
 293     OCEntityHandlerRequest * getRequest = getEntityRequest(OC_REST_GET, OC_OBSERVE_NO_OPTION);
 294     std::string query = std::string("if=") + NS_INTERFACE_BASELINE;
 295     getRequest->query = strdup(query.c_str());
 296     auto ret = NSEntityHandlerTopicCb(flag, getRequest, NULL);
 297
 298     EXPECT_EQ(ret, OC_EH_OK);
 299
 300     free(getRequest->query);
 301     free(getRequest);
 302 }
 303
 304 TEST(NotificationProviderTest, ExpectCallbackReceiveSync)
 305 {
 306     int id = 100;
 307     int type = NS_SYNC_READ;
 308
 309     OCEntityHandlerFlag flag = OC_REQUEST_FLAG;
 310     NSEntityHandlerSyncCb(flag, getPostSyncEntityRequest(id), NULL);
 311
 312     std::unique_lock< std::mutex > lock{ responseProviderSyncLock };
 313     responseProviderSync.wait_for(lock, g_waitForResponse);
 314
 315     EXPECT_EQ(expectedMsgId, id);
 316     EXPECT_EQ(expectedSyncType, type);
 317 }
 318
 319 TEST(NotificationProviderTest, ExpectSuccessSetTopics)
 320 {
 321     std::string str("TEST1");
 322     std::string str2("TEST2");
 323     auto ret = NSProviderRegisterTopic(str.c_str());
 324     EXPECT_EQ(NS_OK, ret);
 325     ret = NSProviderRegisterTopic(str2.c_str());
 326     EXPECT_EQ(NS_OK, ret);
 327 }
 328
 329 TEST(NotificationProviderTest, ExpectSuccessUnsetTopics)
 330 {
 331     std::string str("TEST1");
 332     std::string str2("TEST2");
 333     auto ret = NSProviderUnregisterTopic(str.c_str());
 334     EXPECT_EQ(NS_OK, ret);
 335     ret = NSProviderUnregisterTopic(str2.c_str());
 336     EXPECT_EQ(NS_OK, ret);
 337 }
 338
 339 TEST(NotificationProviderTest, ExpectSuccessTopicAllowConsumer)
 340 {
 341     std::string str("TEST1");
 342     std::string str2("TEST2");
 343     auto ret = NSProviderRegisterTopic(str.c_str());
 344     EXPECT_EQ(NS_OK, ret);
 345     ret = NSProviderRegisterTopic(str2.c_str());
 346     EXPECT_EQ(NS_OK, ret);
 347
 348     ret = NSProviderSetConsumerTopic(g_consumerID, str.c_str());
 349     EXPECT_EQ(NS_OK, ret);
 350     ret = NSProviderSetConsumerTopic(g_consumerID, str2.c_str());
 351     EXPECT_EQ(NS_OK, ret);
 352 }
 353
 354 TEST(NotificationProviderTest, ExpectSuccessTopicDenyConsumer)
 355 {
 356     std::string str("TEST1");
 357     std::string str2("TEST2");
 358
 359     auto ret = NSProviderUnsetConsumerTopic(g_consumerID, str.c_str());
 360     EXPECT_EQ(NS_OK, ret);
 361     ret = NSProviderUnsetConsumerTopic(g_consumerID, str2.c_str());
 362     EXPECT_EQ(NS_OK, ret);
 363 }
 364
 365 TEST(NotificationProviderTest, ExpectEqualUnSetConsumerTopicsAndGetConsumerTopics)
 366 {
 367     std::string str("TEST1");
 368     std::string str2("TEST2");
 369     NSProviderSetConsumerTopic(g_consumerID, str2.c_str());
 370
 371     bool isSame = false;
 372
 373     NSTopicLL * topics = NSProviderGetConsumerTopics(g_consumerID);
 374
 375     if(!topics)
 376     {
 377         isSame = false;
 378     }
 379     else
 380     {
 381         NSTopicLL * firstData = topics;
 382         NSTopicLL * secondData = firstData->next;
 383
 384         if(str.compare(firstData->topicName) == 0 && str2.compare(secondData->topicName) == 0
 385                 && ((int)firstData->state) == 0 && ((int)secondData->state) == 1)
 386         {
 387             isSame = true;
 388         }
 389     }
 390
 391     removeTopics(topics);
 392
 393     NSProviderUnregisterTopic(str.c_str());
 394     NSProviderUnregisterTopic(str2.c_str());
 395     EXPECT_EQ(isSame, true);
 396 }
 397
 398 TEST(NotificationProviderTest, ExpectSuccessCreateMessage)
 399 {
 400     auto msg = NSCreateMessage();
 401     EXPECT_NE((void *)NULL, msg);
 402     NSFreeMessage(msg);
 403 }
 404
 405 TEST(NotificationProviderTest, ExpectCopyMessage)
 406 {
 407     auto msg = NSCreateMessage();
 408     auto copied = NSDuplicateMessage(msg);
 409     EXPECT_EQ(msg->messageId, copied->messageId);
 410     NSFreeMessage(msg);
 411     NSFreeMessage(copied);
 412 }
 413
 414 TEST(NotificationProviderTest, ExpectSuccessSendMessage)
 415 {
 416     auto msg = NSCreateMessage();
 417     auto ret = NSSendMessage(msg);
 418     EXPECT_EQ(NS_OK, ret);
 419     NSFreeMessage(msg);
 420 }
 421
 422 TEST(NotificationProviderTest, ExpectCopyConsumer)
 423 {
 424     auto consumer = (NSConsumer *)malloc(sizeof(NSConsumer));
 425     strcpy(consumer->consumerId, g_consumerID);
 426
 427     auto copied = NSDuplicateConsumer(consumer);
 428     EXPECT_EQ(0, strcmp(copied->consumerId, consumer->consumerId));
 429
 430     NSFreeConsumer(consumer);
 431     NSFreeConsumer(copied);
 432 }
 433
 434 TEST(NotificationProviderTest, ExpectFailSendMessageWithNULL)
 435 {
 436     NSResult ret = NSSendMessage(NULL);
 437     EXPECT_NE(NS_OK, ret);
 438 }
 439
 440 TEST(NotificationProviderTest, ExpectFailAcceptSubscription)
 441 {
 442     NSResult result;
 443     result = NS_SUCCESS;
 444     result = NSAcceptSubscription(NULL, true);
 445     result = NSAcceptSubscription("\0", true);
 446
 447     EXPECT_EQ(result, NS_FAIL);
 448 }
 449
 450 TEST(NotificationProviderTest, ExpectFailRegisterTopic)
 451 {
 452     NSResult result;
 453     result = NS_SUCCESS;
 454     result = NSProviderRegisterTopic(NULL);
 455     result = NSProviderRegisterTopic("\0");
 456
 457     EXPECT_EQ(result, NS_FAIL);
 458 }
 459
 460 TEST(NotificationProviderTest, ExpectFailUnregisterTopic)
 461 {
 462     NSResult result;
 463     result = NS_SUCCESS;
 464     result = NSProviderUnregisterTopic(NULL);
 465     result = NSProviderUnregisterTopic("\0");
 466
 467     EXPECT_EQ(result, NS_FAIL);
 468 }
 469
 470 TEST(NotificationProviderTest, ExpectFailGetConsumerTopics)
 471 {
 472     NSTopicLL topic;
 473     NSTopicLL * topicLL = &topic;
 474
 475     topicLL = NSProviderGetConsumerTopics(NULL);
 476     topicLL = NSProviderGetConsumerTopics("\0");
 477
 478     EXPECT_EQ(topicLL, (NSTopicLL *)NULL);
 479 }
 480
 481 TEST(NotificationProviderTest, ExpectFailSetConsumerTopics)
 482 {
 483     NSResult result;
 484     result = NS_SUCCESS;
 485     result = NSProviderSetConsumerTopic(NULL, NULL);
 486     result = NSProviderSetConsumerTopic(NULL, "\0");
 487     result = NSProviderSetConsumerTopic("\0", NULL);
 488     result = NSProviderSetConsumerTopic("\0", "\0");
 489     result = NSProviderSetConsumerTopic("abc", NULL);
 490     result = NSProviderSetConsumerTopic(NULL, "abc");
 491     result = NSProviderSetConsumerTopic("abc", "\0");
 492     result = NSProviderSetConsumerTopic("\0", "abc");
 493
 494     EXPECT_EQ(result, NS_FAIL);
 495 }
 496
 497 TEST(NotificationProviderTest, ExpectFailUnsetConsumerTopics)
 498 {
 499     NSResult result;
 500     result = NS_SUCCESS;
 501     result = NSProviderUnsetConsumerTopic(NULL, NULL);
 502     result = NSProviderUnsetConsumerTopic(NULL, "\0");
 503     result = NSProviderUnsetConsumerTopic("\0", NULL);
 504     result = NSProviderUnsetConsumerTopic("\0", "\0");
 505     result = NSProviderUnsetConsumerTopic("abc", NULL);
 506     result = NSProviderUnsetConsumerTopic(NULL, "abc");
 507     result = NSProviderUnsetConsumerTopic("abc", "\0");
 508     result = NSProviderUnsetConsumerTopic("\0", "abc");
 509
 510     EXPECT_EQ(result, NS_FAIL);
 511 }
 512
 513 TEST(NotificationProviderTest, ExpectSuccessUnsub)
 514 {
 515     OCEntityHandlerFlag flag = OC_OBSERVE_FLAG;
 516     OCEntityHandlerRequest * msgRequest =
 517             getEntityRequest(OC_REST_OBSERVE, OC_OBSERVE_DEREGISTER);
 518     NSEntityHandlerMessageCb(flag, msgRequest, NULL);
 519     {
 520         std::unique_lock< std::mutex > lock{ responseProviderSubLock };
 521         responseProviderSub.wait_for(lock, g_waitForResponse);
 522     }
 523     free(msgRequest->query);
 524     free(msgRequest);
 525
 526     OCEntityHandlerRequest * syncRequest =
 527             getEntityRequest(OC_REST_OBSERVE, OC_OBSERVE_DEREGISTER);
 528     NSEntityHandlerSyncCb(flag, syncRequest, NULL);
 529     {
 530         std::unique_lock< std::mutex > lock{ responseProviderSubLock };
 531         responseProviderSub.wait_for(lock, g_waitForResponse);
 532     }
 533     free(syncRequest->query);
 534     free(syncRequest);
 535
 536     NSStopProvider();
 537 }