resource/csdk/connectivity/test/ca_api_unittest.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2014 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 "cainterface.h"
  23 #include "cacommon.h"
  24
  25
  26 class CATests : public testing::Test {
  27     protected:
  28     virtual void SetUp() {
  29         CAInitialize();
  30     }
  31
  32     virtual void TearDown()
  33     {
  34         CATerminate();
  35     }
  36 };
  37
  38 void request_handler(CAEndpoint_t* object, CARequestInfo_t* requestInfo);
  39 void response_handler(CAEndpoint_t* object, CAResponseInfo_t* responseInfo);
  40 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  41 CAResult_t checkGetNetworkInfo();
  42 CAResult_t checkSelectNetwork();
  43
  44 void request_handler(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo)
  45 {
  46
  47 }
  48
  49 void response_handler(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
  50 {
  51
  52 }
  53
  54 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo)
  55 {
  56     if(!object || !errorInfo)
  57     {
  58         return;
  59     }
  60
  61     //error handling shall be added
  62     return;
  63 }
  64
  65 static char* uri = NULL;
  66 static CAEndpoint_t* tempRep = NULL;
  67 static CARequestInfo_t requestInfo;
  68 static CAInfo_t requestData;
  69 static CAInfo_t responseData;
  70 static CAResponseInfo_t responseInfo;
  71 static CAToken_t tempToken = NULL;
  72 static uint8_t tokenLength = CA_MAX_TOKEN_LEN;
  73 static const char URI[] = "coap://10.11.12.13:4545/a/light";
  74 static const char RESOURCE_URI[] = "/a/light";
  75
  76 static const char SECURE_INFO_DATA[] =
  77                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  78                                      "\"if\":[\"oc.mi.def\"],\"obs\":1,\"sec\":1,\"port\":%d}}]}";
  79 static const char NORMAL_INFO_DATA[] =
  80                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  81                                      "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
  82
  83 #ifdef __WITH_DTLS__
  84
  85 /**
  86  * @def RS_IDENTITY
  87  * @brief
  88  */
  89 #define IDENTITY     ("1111111111111111")
  90 /* @def RS_CLIENT_PSK
  91  * @brief
  92  */
  93 #define RS_CLIENT_PSK   ("AAAAAAAAAAAAAAAA")
  94
  95 static CADtlsPskCredsBlob_t *pskCredsBlob = NULL;
  96
  97 void clearDtlsCredentialInfo()
  98 {
  99     printf("clearDtlsCredentialInfo IN\n");
 100     if (pskCredsBlob)
 101     {
 102         // Initialize sensitive data to zeroes before freeing.
 103         memset(pskCredsBlob->creds, 0, sizeof(OCDtlsPskCreds) * (pskCredsBlob->num));
 104         free(pskCredsBlob->creds);
 105
 106         memset(pskCredsBlob, 0, sizeof(CADtlsPskCredsBlob_t));
 107         free(pskCredsBlob);
 108         pskCredsBlob = NULL;
 109     }
 110     printf("clearDtlsCredentialInfo OUT\n");
 111 }
 112
 113 // Internal API. Invoked by OC stack to retrieve credentials from this module
 114 void CAGetDtlsPskCredentials(CADtlsPskCredsBlob_t **credInfo)
 115 {
 116     printf("CAGetDtlsPskCredentials IN\n");
 117
 118     if (pskCredsBlob != NULL)
 119     {
 120         *credInfo = pskCredsBlob;
 121     }
 122
 123     printf("CAGetDtlsPskCredentials OUT\n");
 124 }
 125
 126 int32_t SetCredentials()
 127 {
 128     printf("SetCredentials IN\n");
 129     pskCredsBlob = (CADtlsPskCredsBlob_t *)malloc(sizeof(CADtlsPskCredsBlob_t));
 130
 131     memset(pskCredsBlob, 0x0, sizeof(CADtlsPskCredsBlob_t));
 132     memcpy(pskCredsBlob->identity, IDENTITY, DTLS_PSK_ID_LEN);
 133
 134     pskCredsBlob->num = 1;
 135
 136     pskCredsBlob->creds = (OCDtlsPskCreds *)malloc(sizeof(OCDtlsPskCreds) * (pskCredsBlob->num));
 137
 138     memcpy(pskCredsBlob->creds[0].id, IDENTITY, DTLS_PSK_ID_LEN);
 139     memcpy(pskCredsBlob->creds[0].psk, RS_CLIENT_PSK, DTLS_PSK_PSK_LEN);
 140
 141     printf("SetCredentials OUT\n");
 142     return 1;
 143 }
 144 #endif
 145
 146 int main(int argc, char **argv)
 147 {
 148     testing::InitGoogleTest(&argc, argv);
 149     return RUN_ALL_TESTS();
 150 }
 151
 152 // CAInitialize TC
 153 // check return value
 154 TEST(InitializeTest, TC_01_Positive_01)
 155 {
 156     EXPECT_EQ(CA_STATUS_OK, CAInitialize());
 157     CATerminate();
 158 }
 159
 160 //CATerminate TC
 161 TEST_F(CATests, TerminateTest)
 162 {
 163     CATerminate();
 164
 165     char* check = (char *) "terminate success";
 166     EXPECT_STREQ(check, "terminate success");
 167
 168     CAInitialize();
 169 }
 170 // CAStartListeningServer TC
 171 // check return value
 172 TEST(StartListeningServerTest, DISABLED_TC_03_Positive_01)
 173 {
 174     CASelectNetwork(CA_IPV4);
 175     EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
 176 }
 177
 178 // CAStartDiscoveryServer TC
 179 // check return value
 180 TEST(StartDiscoveryServerTest, DISABLED_TC_04_Positive_01)
 181 {
 182     EXPECT_EQ(CA_STATUS_OK, CAStartDiscoveryServer());
 183 }
 184
 185 // CARegisterHandlerTest TC
 186 // check return value
 187 TEST_F(CATests, RegisterHandlerTest)
 188 {
 189     CARegisterHandler(request_handler, response_handler, error_handler);
 190     char* check = (char *) "registerHandler success";
 191     EXPECT_STREQ(check, "registerHandler success");
 192 }
 193
 194 // CACreateRemoteEndpoint TC
 195 // check return value
 196 TEST_F(CATests, CreateRemoteEndpointTestGood)
 197 {
 198     uri = (char *) URI;
 199
 200     EXPECT_EQ(CA_STATUS_OK, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep));
 201
 202     if (tempRep != NULL)
 203     {
 204         CADestroyEndpoint(tempRep);
 205         tempRep = NULL;
 206     }
 207 }
 208
 209 // check remoteEndpoint and values of remoteEndpoint
 210 TEST_F(CATests, CreateRemoteEndpointTestValues)
 211 {
 212     uri = (char *) URI;
 213
 214     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 215
 216     EXPECT_TRUE(tempRep != NULL);
 217
 218     if (tempRep != NULL)
 219     {
 220         CADestroyEndpoint(tempRep);
 221         tempRep = NULL;
 222     }
 223 }
 224
 225 // check return value when uri is NULL
 226 TEST_F(CATests, CreateRemoteEndpointTestBad)
 227 {
 228     uri = NULL;
 229
 230     EXPECT_EQ(CA_STATUS_FAILED, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep));
 231
 232     if (tempRep != NULL)
 233     {
 234         CADestroyEndpoint(tempRep);
 235         tempRep = NULL;
 236     }
 237 }
 238
 239 // CAGerateToken TC
 240 // check return value
 241 TEST_F(CATests, GenerateTokenTestGood)
 242 {
 243     EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken, tokenLength));
 244
 245     CADestroyToken(tempToken);
 246 }
 247
 248 // check return value when CAGenerateToken is passed a NULL instead a valid pointer
 249 TEST_F(CATests, GenerateTokenTestBad)
 250 {
 251     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAGenerateToken(NULL, tokenLength));
 252 }
 253
 254 // CADestroyToken TC
 255 // check destroyed token
 256 TEST_F(CATests, DestroyTokenTest)
 257 {
 258     CAGenerateToken(&tempToken, tokenLength);
 259     CADestroyToken(tempToken);
 260
 261     char * check = (char *) "destroy success";
 262     EXPECT_STREQ(check, "destroy success");
 263 }
 264
 265 // CASendRequest TC
 266 // check return value
 267 TEST(SendRequestTest, DISABLED_TC_16_Positive_01)
 268 {
 269     uri = (char *) URI;
 270     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 271
 272     memset(&requestData, 0, sizeof(CAInfo_t));
 273     CAGenerateToken(&tempToken, tokenLength);
 274     requestData.token = tempToken;
 275     requestData.tokenLength = tokenLength;
 276
 277     int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
 278     requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
 279     if(!requestData.payload)
 280     {
 281         CADestroyToken(tempToken);
 282         FAIL() << "requestData.payload allocation failed";
 283     }
 284     snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
 285     requestData.type = CA_MSG_NONCONFIRM;
 286
 287     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 288     requestInfo.method = CA_GET;
 289     requestInfo.info = requestData;
 290
 291     EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
 292
 293     CADestroyToken(tempToken);
 294
 295     free(requestData.payload);
 296
 297     CADestroyEndpoint(tempRep);
 298     tempRep = NULL;
 299
 300 }
 301
 302 // check return value when uri is NULL
 303 TEST_F(CATests, SendRequestTestWithNullURI)
 304 {
 305     uri = NULL;
 306     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 307
 308     memset(&requestData, 0, sizeof(CAInfo_t));
 309     CAGenerateToken(&tempToken, tokenLength);
 310     requestData.token = tempToken;
 311     requestData.tokenLength = tokenLength;
 312
 313     int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
 314     requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
 315     if(!requestData.payload)
 316     {
 317         CADestroyToken(tempToken);
 318         FAIL() << "requestData.payload allocation failed";
 319     }
 320     snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
 321     requestData.type = CA_MSG_NONCONFIRM;
 322
 323     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 324     requestInfo.method = CA_GET;
 325     requestInfo.info = requestData;
 326
 327     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, &requestInfo));
 328
 329     CADestroyToken(tempToken);
 330
 331     free(requestData.payload);
 332
 333     if (tempRep != NULL)
 334     {
 335         CADestroyEndpoint(tempRep);
 336         tempRep = NULL;
 337     }
 338 }
 339
 340 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
 341 TEST_F(CATests, SendRequestTestWithNullAddr)
 342 {
 343     uri = (char *) URI;
 344     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 345
 346     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
 347
 348     if (tempRep != NULL)
 349     {
 350         CADestroyEndpoint(tempRep);
 351         tempRep = NULL;
 352     }
 353 }
 354
 355 // CASendResponse TC
 356 // check return value
 357 TEST(SendResponseTest, DISABLED_TC_19_Positive_01)
 358 {
 359     uri = (char *) URI;
 360     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 361
 362     memset(&responseData, 0, sizeof(CAInfo_t));
 363     responseData.type = CA_MSG_NONCONFIRM;
 364     responseData.messageId = 1;
 365     responseData.payload = (char *) "response payload";
 366
 367     CAGenerateToken(&tempToken, tokenLength);
 368     requestData.token = tempToken;
 369     requestData.tokenLength = tokenLength;
 370
 371     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 372     responseInfo.result = CA_SUCCESS;
 373     responseInfo.info = responseData;
 374
 375     EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 376
 377     CADestroyToken(tempToken);
 378     CADestroyEndpoint(tempRep);
 379     tempRep = NULL;
 380 }
 381
 382 // check return value when uri is NULL
 383 TEST(SendResponseTest, DISABLED_TC_20_Negative_01)
 384 {
 385     uri = NULL;
 386     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 387
 388     memset(&responseData, 0, sizeof(CAInfo_t));
 389     responseData.type = CA_MSG_NONCONFIRM;
 390     responseData.messageId = 1;
 391     responseData.payload = (char *) "response payload";
 392
 393     CAGenerateToken(&tempToken, tokenLength);
 394     requestData.token = tempToken;
 395     requestData.tokenLength = tokenLength;
 396
 397     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 398     responseInfo.result = CA_SUCCESS;
 399     responseInfo.info = responseData;
 400
 401     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, &responseInfo));
 402
 403     CADestroyToken(tempToken);
 404     if (tempRep != NULL)
 405     {
 406         CADestroyEndpoint(tempRep);
 407         tempRep = NULL;
 408     }
 409 }
 410
 411 // check return value NULL is passed instead of a valid CAResponseInfo_t address
 412 TEST_F(CATests, SendResponseTest)
 413 {
 414     uri = (char *) URI;
 415     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 416
 417     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
 418
 419     if (tempRep != NULL)
 420     {
 421         CADestroyEndpoint(tempRep);
 422         tempRep = NULL;
 423     }
 424 }
 425
 426 // CASendNotification TC
 427 // check return value
 428 TEST(SendNotificationTest, DISABLED_TC_22_Positive_01)
 429 {
 430     uri = (char *) URI;
 431     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 432
 433     memset(&responseData, 0, sizeof(CAInfo_t));
 434     responseData.type = CA_MSG_NONCONFIRM;
 435     responseData.payload = (char *) "Temp Notification Data";
 436
 437     CAGenerateToken(&tempToken, tokenLength);
 438     requestData.token = tempToken;
 439     requestData.tokenLength = tokenLength;
 440
 441     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 442     responseInfo.result = CA_SUCCESS;
 443     responseInfo.info = responseData;
 444
 445     EXPECT_EQ(CA_STATUS_OK, CASendNotification(tempRep, &responseInfo));
 446
 447     CADestroyToken(tempToken);
 448     if (tempRep != NULL)
 449     {
 450         CADestroyEndpoint(tempRep);
 451         tempRep = NULL;
 452     }
 453 }
 454
 455 // check return value when uri is NULL
 456 TEST_F(CATests, SendNotificationTest)
 457 {
 458     uri = NULL;
 459     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
 460
 461     memset(&responseData, 0, sizeof(CAInfo_t));
 462     responseData.type = CA_MSG_NONCONFIRM;
 463     responseData.payload = (char *) "Temp Notification Data";
 464
 465     CAGenerateToken(&tempToken, tokenLength);
 466     requestData.token = tempToken;
 467     requestData.tokenLength = tokenLength;
 468
 469     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 470     responseInfo.result = CA_SUCCESS;
 471     responseInfo.info = responseData;
 472
 473     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendNotification(tempRep, &responseInfo));
 474
 475     CADestroyToken(tempToken);
 476     if (tempRep != NULL)
 477     {
 478         CADestroyEndpoint(tempRep);
 479         tempRep = NULL;
 480     }
 481 }
 482
 483 // CASelectNewwork TC
 484 // check return value
 485 TEST_F(CATests, SelectNetworkTestGood)
 486 {
 487     CAResult_t res = checkSelectNetwork();
 488     EXPECT_EQ(CA_STATUS_OK, res);
 489 }
 490
 491 CAResult_t checkSelectNetwork()
 492 {
 493     CAResult_t res = CASelectNetwork(CA_ADAPTER_IP);
 494
 495     if (CA_STATUS_OK == res)
 496     {
 497         EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
 498         return CA_STATUS_OK;
 499     }
 500     if (CA_NOT_SUPPORTED == res)
 501     {
 502         EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(CA_ADAPTER_IP));
 503         return CA_STATUS_OK;
 504     }
 505
 506     return res;
 507 }
 508
 509 // check return value when selected network is disable
 510 TEST_F(CATests, SelectNetworkTestBad)
 511 {
 512     //Select disable network
 513     EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork(1000));
 514 }
 515
 516 // check return value when selected network is disable
 517 TEST_F(CATests, UnSelectNetworkTest)
 518 {
 519     //UnSelect disable network
 520     EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(1000));
 521 }
 522
 523 // CAHandlerRequestResponse TC
 524 // check return value
 525 TEST_F(CATests, HandlerRequestResponseTest)
 526 {
 527     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 528 }
 529
 530 // CAGetNetworkInformation TC
 531 // check return value
 532 TEST_F (CATests, GetNetworkInformationTestGood)
 533 {
 534     EXPECT_EQ(CA_STATUS_OK, checkGetNetworkInfo());
 535 }
 536
 537 TEST_F(CATests, RegisterDTLSCredentialsHandlerTest)
 538 {
 539 #ifdef __WITH_DTLS__
 540     if (SetCredentials() == 0)
 541     {
 542         printf("SetCredentials failed\n");
 543     }
 544
 545     EXPECT_EQ(CA_STATUS_OK, CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials));
 546 #endif
 547 }
 548
 549 CAResult_t checkGetNetworkInfo()
 550 {
 551     CAEndpoint_t *tempInfo = NULL;
 552     uint32_t tempSize = 0;
 553
 554     CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
 555
 556     free(tempInfo);
 557
 558     if (CA_STATUS_OK == res || CA_ADAPTER_NOT_ENABLED == res ||
 559             CA_NOT_SUPPORTED == res)
 560     {
 561         return CA_STATUS_OK;
 562     }
 563     else
 564     {
 565         return CA_STATUS_FAILED;
 566     }
 567 }