resource/csdk/security/unittest/doxmresource.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 "ocserverrequest.h"
  24 #include "oic_string.h"
  25 #include "oic_malloc.h"
  26 #include "resourcemanager.h"
  27 #include "securevirtualresourcetypes.h"
  28 #include "srmresourcestrings.h"
  29 #include "doxmresource.h"
  30 #include "security_internals.h"
  31
  32 #define TAG  "SRM-DOXM"
  33
  34 OicSecDoxm_t * getBinDoxm()
  35 {
  36     OicSecDoxm_t *doxm = (OicSecDoxm_t *)OICCalloc(1, sizeof(*doxm));
  37     if (!doxm)
  38     {
  39         return NULL;
  40     }
  41     doxm->oxmTypeLen =  1;
  42     doxm->oxmType = (OicUrn_t *)OICCalloc(doxm->oxmTypeLen, sizeof(*doxm->oxmType));
  43     if (!doxm->oxmType)
  44     {
  45         OICFree(doxm);
  46         return NULL;
  47     }
  48     doxm->oxmType[0] = (char *) OICMalloc(strlen(OXM_JUST_WORKS) + 1);
  49     if (!doxm->oxmType[0])
  50     {
  51         OICFree(doxm->oxmType);
  52         OICFree(doxm);
  53         return NULL;
  54     }
  55
  56     OICStrcpy(doxm->oxmType[0], strlen(OXM_JUST_WORKS) + 1, OXM_JUST_WORKS);
  57     doxm->oxmLen     = 1;
  58     doxm->oxm        = (OicSecOxm_t *)OICCalloc(doxm->oxmLen, sizeof(OicSecOxm_t));
  59     if(!doxm->oxm)
  60     {
  61         OICFree(doxm->oxmType[0]);
  62         OICFree(doxm->oxmType);
  63         OICFree(doxm);
  64         return NULL;
  65     }
  66
  67     doxm->oxm[0]     = OIC_JUST_WORKS;
  68     doxm->oxmSel     = OIC_JUST_WORKS;
  69     doxm->sct        = SYMMETRIC_PAIR_WISE_KEY;
  70     doxm->owned      = true;
  71     //TODO: Need more clarification on deviceIDFormat field type.
  72     //doxm.deviceIDFormat = URN;
  73
  74     uint8_t deviceId[] = {0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64};
  75     memcpy(doxm->deviceID.id, deviceId, sizeof(deviceId));
  76     uint8_t ownerId[] = {0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x49, 0x64};
  77     memcpy(doxm->owner.id, ownerId, sizeof(ownerId));
  78     return doxm;
  79 }
  80
  81  //InitDoxmResource Tests
  82 TEST(DoxmResourceTest, InitDoxmResource)
  83 {
  84     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitDoxmResource());
  85 }
  86
  87 //DeInitDoxmResource Tests
  88 TEST(DoxmResourceTest, DeInitDoxmResource)
  89 {
  90     EXPECT_EQ(OC_STACK_ERROR, DeInitDoxmResource());
  91 }
  92
  93 //CreateDoxmResource Tests
  94 TEST(DoxmResourceTest, CreateDoxmResource)
  95 {
  96     EXPECT_EQ(OC_STACK_INVALID_PARAM, CreateDoxmResource());
  97 }
  98
  99  //DoxmEntityHandler Tests
 100 TEST(DoxmResourceTest, DoxmEntityHandlerWithDummyRequest)
 101 {
 102     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 103     EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
 104 }
 105
 106 TEST(DoxmResourceTest, DoxmEntityHandlerWithNULLRequest)
 107 {
 108     EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, NULL, NULL));
 109 }
 110
 111 TEST(DoxmResourceTest, DoxmEntityHandlerInvalidFlag)
 112 {
 113     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 114     EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, &req, NULL));
 115 }
 116
 117 TEST(DoxmResourceTest, DoxmEntityHandlerValidRequest)
 118 {
 119     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitDoxmResource());
 120     char query[] = "oxm=0;owned=false;owner=owner1";
 121     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 122     req.method = OC_REST_GET;
 123     req.query = OICStrdup(query);
 124     EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
 125
 126     OICFree(req.query);
 127 }
 128
 129 TEST(DoxmResourceTest, DoxmEntityHandlerDeviceIdQuery)
 130 {
 131     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitDoxmResource());
 132     char query[] = "deviceuuid=2222222222222222";
 133     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 134     req.method = OC_REST_GET;
 135     req.query = OICStrdup(query);
 136     EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
 137
 138     OICFree(req.query);
 139 }
 140
 141 TEST(DoxmResourceTest, DoxmToCBORPayloadNULL)
 142 {
 143     OicSecDoxm_t *doxm =  getBinDoxm();
 144     size_t size = 10;
 145     uint8_t *payload = NULL;
 146     EXPECT_EQ(OC_STACK_INVALID_PARAM, DoxmToCBORPayload(NULL, NULL, 0, false));
 147     EXPECT_EQ(OC_STACK_INVALID_PARAM, DoxmToCBORPayload(doxm, NULL, &size, false));
 148     EXPECT_EQ(OC_STACK_INVALID_PARAM, DoxmToCBORPayload(doxm, &payload, 0, false));
 149     EXPECT_EQ(OC_STACK_INVALID_PARAM, DoxmToCBORPayload(NULL, &payload, &size, false));
 150     DeleteDoxmBinData(doxm);
 151 }
 152
 153 TEST(DoxmResourceTest, DoxmToCBORPayloadVALID)
 154 {
 155     OicSecDoxm_t *doxm =  getBinDoxm();
 156
 157     uint8_t *payload = NULL;
 158     size_t size = 0;
 159     EXPECT_EQ(OC_STACK_OK, DoxmToCBORPayload(doxm, &payload, &size, false));
 160     EXPECT_TRUE(payload != NULL);
 161
 162     DeleteDoxmBinData(doxm);
 163     OICFree(payload);
 164 }
 165
 166 //CBORPayloadToDoxm Tests
 167 TEST(DoxmResourceTest, CBORPayloadToDoxmNULL)
 168 {
 169     OicSecDoxm_t *doxm = NULL;
 170     uint8_t *cborPayload = (uint8_t *)OICCalloc(1, sizeof(uint8_t));
 171     size_t size = 10;
 172     ASSERT_TRUE(NULL != cborPayload);
 173     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDoxm(NULL, 0, NULL));
 174     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDoxm(NULL, size, &doxm));
 175     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDoxm(cborPayload, size, NULL));
 176     OICFree(cborPayload);
 177 }
 178
 179 TEST(DoxmResourceTest, CBORPayloadToDoxmVALID)
 180 {
 181     OicSecDoxm_t *doxm =  getBinDoxm();
 182     uint8_t *payload = NULL;
 183     size_t size = 0;
 184     EXPECT_EQ(OC_STACK_OK, DoxmToCBORPayload(doxm, &payload, &size, false));
 185     EXPECT_TRUE(payload != NULL);
 186
 187     OicSecDoxm_t *doxmSec = NULL;
 188     EXPECT_EQ(OC_STACK_OK, CBORPayloadToDoxm(payload, size, &doxmSec));
 189     ASSERT_TRUE(doxmSec != NULL);
 190     EXPECT_EQ(doxmSec->oxmTypeLen, doxm->oxmTypeLen);
 191     EXPECT_STREQ(doxmSec->oxmType[0], doxm->oxmType[0]);
 192     EXPECT_EQ(doxmSec->oxmLen, doxm->oxmLen);
 193     EXPECT_EQ(doxmSec->oxm[0], doxm->oxm[0]);
 194     EXPECT_EQ(doxmSec->oxmSel, doxm->oxmSel);
 195     EXPECT_EQ(doxmSec->sct, doxm->sct);
 196     EXPECT_EQ(doxmSec->owned, doxm->owned);
 197
 198     DeleteDoxmBinData(doxmSec);
 199     DeleteDoxmBinData(doxm);
 200     OICFree(payload);
 201 }