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 #ifdef HAVE_UNISTD_H
  22 #include <unistd.h>
  23 #endif
  24 #include "gtest/gtest.h"
  25
  26 #include "ocpayload.h"
  27 #include "ocstack.h"
  28 #include "oic_malloc.h"
  29 #include "cainterface.h"
  30 #include "resourcemanager.h"
  31 #include "secureresourcemanager.h"
  32 #include "pstatresource.h"
  33 #include "security_internals.h"
  34
  35 // InitPstatResource Tests
  36 TEST(PstatResourceTest, InitPstatResource)
  37 {
  38     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitPstatResource());
  39 }
  40
  41 // DeInitPstatResource Tests
  42 TEST(PstatResourceTest, DeInitPstatResource)
  43 {
  44     EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitPstatResource());
  45 }
  46
  47 //CreatePstatResource Tests
  48 TEST(PstatResourceTest, CreatePstatResource)
  49 {
  50     EXPECT_EQ(OC_STACK_INVALID_PARAM, CreatePstatResource());
  51 }
  52
  53 //PstatEntityHandler Tests
  54 TEST(PstatResourceTest, PstatEntityHandlerWithDummyRequest)
  55 {
  56     OCEntityHandlerRequest req = OCEntityHandlerRequest();
  57     EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));
  58 }
  59
  60 TEST(PstatResourceTest, PstatEntityHandlerWithPostRequest)
  61 {
  62     OicSecPstat_t *defaultPstat = (OicSecPstat_t *) OICCalloc(1, sizeof(*defaultPstat));
  63     ASSERT_TRUE(defaultPstat != NULL);
  64     defaultPstat->isOp = false;
  65     uint8_t deviceId[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x69, 0x64, 0x00,
  66                           0x00, 0x00, 0x00, 0x00, 0x18, 0x5a, 0x9f};
  67     memcpy(defaultPstat->deviceID.id, deviceId, sizeof(deviceId));
  68     EXPECT_EQ(sizeof(defaultPstat->deviceID.id), sizeof(deviceId));
  69     defaultPstat->commitHash = 1234;
  70     defaultPstat->cm = (OicSecDpm_t) 63;
  71     defaultPstat->tm = (OicSecDpm_t) 48;
  72     defaultPstat->om = (OicSecDpom_t) 0;
  73     defaultPstat->smLen = 1;
  74     defaultPstat->sm = (OicSecDpom_t *)OICCalloc(defaultPstat->smLen, sizeof(*defaultPstat->sm));
  75     ASSERT_TRUE(defaultPstat->sm != NULL);
  76     defaultPstat->sm[0] = (OicSecDpom_t) 3;
  77     size_t size = 0;
  78     uint8_t *cbor = NULL;
  79     EXPECT_EQ(OC_STACK_OK, PstatToCBORPayload(defaultPstat, &cbor, &size, true));
  80     DeletePstatBinData(defaultPstat);
  81     ASSERT_TRUE(cbor != NULL);
  82
  83     OCEntityHandlerRequest req = OCEntityHandlerRequest();
  84     req.method = OC_REST_POST;
  85     req.payload = (OCPayload *) OCSecurityPayloadCreate(cbor, size);
  86     EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));
  87     OICFree(cbor);
  88     OCPayloadDestroy(req.payload);
  89 }
  90
  91 TEST(PstatResourceTest, PstatEntityHandlerInvalidRequest)
  92 {
  93     EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, NULL));
  94 }
  95
  96 TEST(PstatResourceTest, PstatToCBORPayloadNULL)
  97 {
  98     EXPECT_EQ(OC_STACK_INVALID_PARAM, PstatToCBORPayload(NULL, NULL, 0, false));
  99     // Case when cbor payload is NULL
 100     OicSecPstat_t pstat;
 101     size_t size = 10;
 102     EXPECT_EQ(OC_STACK_INVALID_PARAM, PstatToCBORPayload(&pstat, NULL, &size, false));
 103     uint8_t *cborPayload = (uint8_t *) OICCalloc(1, size);
 104     ASSERT_TRUE(NULL != cborPayload);
 105     EXPECT_EQ(OC_STACK_INVALID_PARAM, PstatToCBORPayload(&pstat, &cborPayload, &size, false));
 106     OICFree(cborPayload);
 107     cborPayload = NULL;
 108     // Case when pstat is zero.
 109     EXPECT_EQ(OC_STACK_INVALID_PARAM, PstatToCBORPayload(NULL, &cborPayload, &size, false));
 110     // Case when size is 0.
 111     EXPECT_EQ(OC_STACK_INVALID_PARAM, PstatToCBORPayload(&pstat, &cborPayload, 0, false));
 112     OICFree(cborPayload);
 113 }
 114
 115 TEST(PstatResourceTest, CBORPayloadToPstat)
 116 {
 117     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToPstat(NULL, 0, NULL));
 118 }
 119
 120 TEST(PstatResourceTest, PstatToCBORPayloadAndCBORPayloadToPstat)
 121 {
 122     OicSecPstat_t pstat;
 123     pstat.cm = NORMAL;
 124     pstat.commitHash = 0;
 125     uint8_t deviceId[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x69, 0x64, 0x00,
 126                           0x00, 0x00, 0x00, 0x00, 0x18, 0x5a, 0x9f};
 127     memcpy(pstat.deviceID.id, deviceId, sizeof(deviceId));
 128     pstat.isOp = true;
 129     pstat.tm = NORMAL;
 130     pstat.om = SINGLE_SERVICE_CLIENT_DRIVEN;
 131     pstat.smLen = 1;
 132     pstat.sm = (OicSecDpom_t*)OICCalloc(pstat.smLen, sizeof(*pstat.sm));
 133     ASSERT_TRUE(NULL != pstat.sm);
 134     pstat.sm[0] = SINGLE_SERVICE_CLIENT_DRIVEN;
 135
 136     size_t size = 0;
 137     uint8_t *cbor = NULL;
 138     EXPECT_EQ(OC_STACK_OK, PstatToCBORPayload(&pstat, &cbor, &size, false));
 139     if (!cbor)
 140     {
 141         OICFree(pstat.sm);
 142         FAIL() << "Failed to convert PstatToCBORPayload";
 143         return;
 144     }
 145     ASSERT_TRUE(NULL != cbor);
 146     OicSecPstat_t *pstat1 = NULL;
 147     EXPECT_EQ(OC_STACK_OK, CBORPayloadToPstat(cbor, size, &pstat1));
 148     ASSERT_TRUE(NULL != pstat1);
 149     EXPECT_EQ(pstat.commitHash, pstat1->commitHash);
 150     EXPECT_EQ(pstat.isOp, pstat1->isOp);
 151     EXPECT_EQ(pstat.tm, pstat1->tm);
 152     EXPECT_EQ(pstat.om, pstat1->om);
 153     EXPECT_EQ(pstat.smLen, pstat1->smLen);
 154     EXPECT_EQ(pstat.sm[0], pstat1->sm[0]);
 155
 156     DeletePstatBinData(pstat1);
 157     OICFree(cbor);
 158     OICFree(pstat.sm);
 159 }