resource/csdk/security/unittest/pstatresource.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Mobile Communications GmbH 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 "ocstack.h"
  23 #include "resourcemanager.h"
  24 #include "pstatresource.h"
  25 #include "oic_malloc.h"
  26 #include "cJSON.h"
  27 #include "base64.h"
  28 #include "cainterface.h"
  29 #include "secureresourcemanager.h"
  30 #include <unistd.h>
  31 #ifdef __cplusplus
  32 extern "C" {
  33 #endif
  34 //Declare Provision status resource methods for testing
  35 OCStackResult CreatePstatResource();
  36 OCEntityHandlerResult PstatEntityHandler (OCEntityHandlerFlag flag,
  37                                         OCEntityHandlerRequest * ehRequest);
  38 char * BinToPstatJSON(const OicSecPstat_t * pstat);
  39 OicSecPstat_t * JSONToPstatBin(const char * jsonStr);
  40 char* ReadFile(const char* filename);
  41 const char* UNIT_TEST_JSON_FILE_NAME = "oic_unittest.json";
  42 #ifdef __cplusplus
  43 }
  44 #endif
  45
  46 //InitPstatResource Tests
  47 TEST(InitPstatResourceTest, InitPstatResource)
  48 {
  49     EXPECT_EQ(OC_STACK_INVALID_PARAM,  InitPstatResource());
  50 }
  51
  52
  53 //DeInitPstatResource Tests
  54 TEST(DeInitPstatResourceTest, DeInitPstatResource)
  55 {
  56     EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitPstatResource());
  57 }
  58
  59 //CreatePstatResource Tests
  60 TEST(CreatePstatResourceTest, CreatePstatResource)
  61 {
  62     EXPECT_EQ(OC_STACK_INVALID_PARAM,  CreatePstatResource());
  63 }
  64
  65 //PstatEntityHandler Tests
  66 TEST(PstatEntityHandlerTest, PstatEntityHandlerWithDummyRequest)
  67 {
  68     OCEntityHandlerRequest req;
  69     EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));
  70 }
  71
  72 TEST(PstatEntityHandlerTest, PstatEntityHandlerWithPostRequest)
  73 {
  74     OCEntityHandlerRequest req;
  75     req.method = OC_REST_POST;
  76     req.payload = (OCPayload*)calloc(1, sizeof(OCSecurityPayload));
  77     req.payload->type = PAYLOAD_TYPE_SECURITY;
  78     ((OCSecurityPayload*)req.payload)->securityData =
  79         (char*)"{ \"pstat\": { \"tm\": 0, \"om\": 3 }}";
  80     EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));
  81 }
  82
  83 TEST(PstatEntityHandlerTest, PstatEntityHandlerInvalidRequest)
  84 {
  85     EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, NULL));
  86 }
  87
  88 //BinToJSON Tests
  89 TEST(BinToJSONTest, BinToNullJSON)
  90 {
  91     char* value = BinToPstatJSON(NULL);
  92     EXPECT_TRUE(value == NULL);
  93 }
  94
  95 TEST(JSONToBinTest, NullJSONToBin)
  96 {
  97     OicSecPstat_t *pstat1 = JSONToPstatBin(NULL);
  98     EXPECT_TRUE(pstat1 == NULL);
  99 }
 100
 101 TEST(MarshalingAndUnMarshalingTest, BinToPstatJSONAndJSONToPstatBin)
 102 {
 103     const char* id = "ZGV2aWNlaWQAAAAAABhanw==";
 104     OicSecPstat_t pstat;
 105     pstat.cm = NORMAL;
 106     pstat.commitHash = 0;
 107     uint32_t outLen = 0;
 108     unsigned char base64Buff[sizeof(((OicUuid_t*) 0)->id)] = {};
 109     EXPECT_EQ(B64_OK, b64Decode(id, strlen(id), base64Buff, sizeof(base64Buff), &outLen));
 110     memcpy(pstat.deviceID.id, base64Buff, outLen);
 111     pstat.isOp = true;
 112     pstat.tm = NORMAL;
 113     pstat.om = SINGLE_SERVICE_CLIENT_DRIVEN;
 114     pstat.smLen = 2;
 115     pstat.sm = (OicSecDpom_t*)OICCalloc(pstat.smLen, sizeof(OicSecDpom_t));
 116     pstat.sm[0] = SINGLE_SERVICE_CLIENT_DRIVEN;
 117     pstat.sm[1] = SINGLE_SERVICE_SERVER_DRIVEN;
 118     char* jsonPstat = BinToPstatJSON(&pstat);
 119     printf("BinToJSON Dump:\n%s\n\n", jsonPstat);
 120     EXPECT_TRUE(jsonPstat != NULL);
 121     OicSecPstat_t *pstat1 = JSONToPstatBin(jsonPstat);
 122     EXPECT_TRUE(pstat1 != NULL);
 123     OICFree(pstat1->sm);
 124     OICFree(pstat1);
 125     OICFree(jsonPstat);
 126     OICFree(pstat.sm);
 127 }
 128
 129 TEST(PstatTests, JSONMarshalliingTests)
 130 {
 131     char *jsonStr1 = ReadFile(UNIT_TEST_JSON_FILE_NAME);
 132     if (NULL != jsonStr1)
 133     {
 134         cJSON_Minify(jsonStr1);
 135         /* Workaround : cJSON_Minify does not remove all the unwanted characters
 136          from the end. Here is an attempt to remove those characters */
 137         int len = strlen(jsonStr1);
 138         while (len > 0)
 139         {
 140             if (jsonStr1[--len] == '}')
 141             {
 142                 break;
 143             }
 144         }
 145         jsonStr1[len + 1] = 0;
 146
 147         OicSecPstat_t* pstat = JSONToPstatBin(jsonStr1);
 148         EXPECT_TRUE(NULL != pstat);
 149
 150         char* jsonStr2 = BinToPstatJSON(pstat);
 151         printf("BinToPstatJSON Dump:\n%s\n\n", jsonStr2);
 152         EXPECT_STRNE(jsonStr1, jsonStr2);
 153
 154         OICFree(jsonStr1);
 155         OICFree(jsonStr2);
 156         OICFree(pstat);
 157    }
 158     else
 159     {
 160         printf("Please copy %s into unittest folder\n", UNIT_TEST_JSON_FILE_NAME);
 161     }
 162 }