X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fsecurity%2Funittest%2Faclresourcetest.cpp;h=558406a6921de51d3d1005c97bb2d135c0e4f282;hb=390866079e285d2c74918432c0d597d5da52f8a0;hp=08e7d2670d55ce9fd546cbacbb81f02e8517d990;hpb=3e9402ad71cb3e93266a77796f44d17bab9853fd;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/security/unittest/aclresourcetest.cpp b/resource/csdk/security/unittest/aclresourcetest.cpp index 08e7d26..558406a 100644 --- a/resource/csdk/security/unittest/aclresourcetest.cpp +++ b/resource/csdk/security/unittest/aclresourcetest.cpp @@ -24,10 +24,10 @@ #include #include #include "ocstack.h" +#include "psinterface.h" #include "ocpayload.h" #include "oic_malloc.h" #include "oic_string.h" -#include "cJSON.h" #include "cainterface.h" #include "secureresourcemanager.h" #include "securevirtualresourcetypes.h" @@ -36,197 +36,294 @@ #include "srmtestcommon.h" #include "srmutility.h" #include "logger.h" +#include "doxmresource.h" +#include "ocpayload.h" +#include "ocpayloadcbor.h" +#include "payload_logging.h" +#include "security_internals.h" using namespace std; #define TAG "SRM-ACL-UT" -#ifdef __cplusplus -extern "C" { -#endif - -extern char * BinToAclJSON(const OicSecAcl_t * acl); -extern OicSecAcl_t * JSONToAclBin(const char * jsonStr); -extern void DeleteACLList(OicSecAcl_t* acl); -OCStackResult GetDefaultACL(OicSecAcl_t** defaultAcl); -OCEntityHandlerResult ACLEntityHandler (OCEntityHandlerFlag flag, - OCEntityHandlerRequest * ehRequest); -#ifdef __cplusplus -} -#endif - -const char* JSON_FILE_NAME = "oic_unittest.json"; -const char* DEFAULT_ACL_JSON_FILE_NAME = "oic_unittest_default_acl.json"; -const char* ACL1_JSON_FILE_NAME = "oic_unittest_acl1.json"; +// These paths match jenkins build configuration. +const char* DEFAULT_ACL_FILE_NAME = "/oic_unittest_default_acl.dat"; +const char* ACL1_FILE_NAME = "/oic_unittest_acl1.dat"; -#define NUM_ACE_FOR_WILDCARD_IN_ACL1_JSON (2) +#define NUM_ACE_FOR_WILDCARD_IN_ACL1_DAT (1) -// JSON Marshalling Tests -TEST(ACLResourceTest, JSONMarshallingTests) +TEST(ACLResourceTest, CBORDefaultACLConversion) { - char *jsonStr1 = ReadFile(ACL1_JSON_FILE_NAME); - if (jsonStr1) + OicSecAcl_t *defaultAcl = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t)); + ASSERT_TRUE(defaultAcl != NULL); + uint8_t defaultAclSub[] = { 0x2a }; + memcpy(defaultAcl->subject.id, defaultAclSub, sizeof(defaultAclSub)); + defaultAcl->permission = 2; + const char *defaulAclRsrc[] = { "/oic/res", "/oic/d", "/oic/p", "/oic/res/types/d", + "/oic/ad", "/oic/sec/acl", "/oic/sec/doxm", "/oic/sec/pstat"}; + defaultAcl->resourcesLen = 8; + defaultAcl->resources = (char **)OICCalloc(defaultAcl->resourcesLen, sizeof(char *)); + ASSERT_TRUE(defaultAcl->resources != NULL); + for (size_t i = 0 ; i < defaultAcl->resourcesLen; i++) { - cJSON_Minify(jsonStr1); - /* Workaround : cJSON_Minify does not remove all the unwanted characters - from the end. Here is an attempt to remove those characters */ - int len = strlen(jsonStr1); - while (len > 0) - { - if (jsonStr1[--len] == '}') - { - break; - } - } - jsonStr1[len + 1] = 0; + defaultAcl->resources[i] = OICStrdup(defaulAclRsrc[i]); + ASSERT_TRUE(defaultAcl->resources[i] != NULL); + } + uint8_t defaultAclOwnrs[] = {0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, + 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32}; + memcpy(defaultAcl->rownerID.id, defaultAclOwnrs, sizeof(defaultAclOwnrs)); + + size_t defaultAclSize = 0; + uint8_t *defaultPsStorage = NULL; + OCStackResult convRet = AclToCBORPayload(defaultAcl, &defaultPsStorage, &defaultAclSize); + EXPECT_EQ(OC_STACK_OK, convRet); + ASSERT_TRUE(defaultPsStorage != NULL); + EXPECT_NE(0, defaultAclSize); + + OicSecAcl_t* convertedAcl = CBORPayloadToAcl(defaultPsStorage, defaultAclSize); + ASSERT_TRUE(convertedAcl != NULL); + + EXPECT_EQ(defaultAcl->resourcesLen, convertedAcl->resourcesLen); + for(int i = 0; i < convertedAcl->resourcesLen; i++) + { + EXPECT_EQ(0, strcmp(defaultAcl->resources[i], convertedAcl->resources[i])); + } - OicSecAcl_t * acl = JSONToAclBin(jsonStr1); - EXPECT_TRUE(NULL != acl); + DeleteACLList(convertedAcl); + DeleteACLList(defaultAcl); + OICFree(defaultPsStorage); +} - char * jsonStr2 = BinToAclJSON(acl); - EXPECT_TRUE(NULL != jsonStr2); +TEST(ACLResourceTest, CBORACLConversion) +{ + OicSecAcl_t *secAcl = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t)); + ASSERT_TRUE(secAcl != NULL); + uint8_t subjectBytes[] = { 0x2a }; + memcpy(secAcl->subject.id, subjectBytes, sizeof(subjectBytes)); + secAcl->permission = 2; + const char *rsrc[] = { "/oic/res", "/oic/d", "/oic/p", "/oic/res/types/d", + "/oic/ad", "/oic/sec/acl"}; + secAcl->resourcesLen = 6; + secAcl->resources = (char **)OICCalloc(secAcl->resourcesLen, sizeof(char *)); + ASSERT_TRUE(secAcl->resources != NULL); + for (size_t i = 0 ; i < secAcl->resourcesLen; i++) + { + secAcl->resources[i] = OICStrdup(rsrc[i]); + ASSERT_TRUE(secAcl->resources[i] != NULL); - EXPECT_STREQ(jsonStr1, jsonStr2); + } - OICFree(jsonStr1); - OICFree(jsonStr2); - DeleteACLList(acl); + uint8_t ownrs[] = {0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, + 0x32, 0x32, 0x32, 0x32, 0x32, 0x32}; + memcpy(secAcl->rownerID.id, ownrs, sizeof(ownrs)); + + OicSecAcl_t *secAcl1 = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t)); + ASSERT_TRUE(secAcl1 != NULL); + memcpy(secAcl1->subject.id, subjectBytes, sizeof(subjectBytes)); + secAcl1->permission = 6; + const char *rsrc1[] = { "/oic/sec/doxm", "/oic/sec/pstat"}; + secAcl1->resourcesLen = 2; + secAcl1->resources = (char **)OICCalloc(secAcl1->resourcesLen, sizeof(char *)); + ASSERT_TRUE(secAcl1->resources != NULL); + for (size_t i = 0 ; i < secAcl1->resourcesLen; i++) + { + secAcl1->resources[i] = OICStrdup(rsrc1[i]); + ASSERT_TRUE(secAcl1->resources[i] != NULL); + } + memcpy(secAcl1->rownerID.id, ownrs, sizeof(ownrs)); + secAcl->next = secAcl1; + + OicSecAcl_t *secAcl2 = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t)); + ASSERT_TRUE(secAcl2 != NULL); + uint8_t subjectBytes1[] = {0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, + 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31}; + memcpy(secAcl2->subject.id, subjectBytes1, sizeof(subjectBytes1)); + secAcl2->permission = 255; + const char *rsrc2[] = {"/oic/light", "/oic/fan" }; + secAcl2->resourcesLen = 2; + secAcl2->resources = (char **)OICCalloc(secAcl2->resourcesLen, sizeof(char *)); + ASSERT_TRUE(secAcl2->resources != NULL); + for (size_t i = 0 ; i < secAcl2->resourcesLen; i++) + { + secAcl2->resources[i] = OICStrdup(rsrc2[i]); + ASSERT_TRUE(secAcl2->resources[i] != NULL); } + memcpy(secAcl2->rownerID.id, ownrs, sizeof(ownrs)); + secAcl1->next = secAcl2; + + OicSecAcl_t *secAcl3 = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t)); + ASSERT_TRUE(secAcl3 != NULL); + uint8_t subjectBytes2[] = {0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33}; + memcpy(secAcl3->subject.id, subjectBytes2, sizeof(subjectBytes2)); + secAcl3->permission = 255; + const char *rsrc3[] = {"/oic/light", "/oic/garage" }; + secAcl3->resourcesLen = 2; + secAcl3->resources = (char **)OICCalloc(secAcl3->resourcesLen, sizeof(char *)); + ASSERT_TRUE(secAcl3->resources != NULL); + for (size_t i = 0 ; i < secAcl3->resourcesLen; i++) + { + secAcl3->resources[i] = OICStrdup(rsrc3[i]); + ASSERT_TRUE(secAcl3->resources[i] != NULL); + } + memcpy(secAcl3->rownerID.id, ownrs, sizeof(ownrs)); + secAcl2->next = secAcl3; + secAcl3->next = NULL; + + size_t size = 0; + uint8_t *psStorage = NULL; + EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(secAcl, &psStorage, &size)); + ASSERT_TRUE(NULL != psStorage); + OicSecAcl_t *acl = CBORPayloadToAcl(psStorage, size); + ASSERT_TRUE(NULL != acl); + EXPECT_EQ(2, acl->permission); + EXPECT_EQ(6 , acl->resourcesLen); + EXPECT_STREQ("/oic/res", acl->resources[0]); + DeleteACLList(acl); + OICFree(psStorage); + DeleteACLList(secAcl); +} + +//InitResource Tests +TEST(ACLResourceTest, InitAclResource) +{ + EXPECT_EQ(OC_STACK_INVALID_PARAM, InitACLResource()); + EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitACLResource()); } // Default ACL tests TEST(ACLResourceTest, GetDefaultACLTests) { - // Read default ACL from the file - char *jsonStr = ReadFile(DEFAULT_ACL_JSON_FILE_NAME); - if (jsonStr) - { - OicSecAcl_t * acl = JSONToAclBin(jsonStr); - EXPECT_TRUE(NULL != acl); + uint8_t *payload = NULL; + size_t size = 0; - // Invoke API to generate default ACL - OicSecAcl_t * defaultAcl = NULL; - OCStackResult ret = GetDefaultACL(&defaultAcl); - EXPECT_TRUE(NULL == defaultAcl); + ASSERT_TRUE(ReadCBORFile(DEFAULT_ACL_FILE_NAME, OIC_JSON_ACL_NAME, &payload, &size)); + ASSERT_TRUE(payload != NULL); - EXPECT_TRUE(OC_STACK_ERROR == ret); + OicSecAcl_t *psAcl = CBORPayloadToAcl(payload, size); + ASSERT_TRUE(psAcl != NULL); - // Verify if the SRM generated default ACL matches with unit test default - if (acl && defaultAcl) + OicSecAcl_t *acl = NULL; + EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&acl)); + ASSERT_TRUE(acl != NULL); + + // Verify if the SRM generated default ACL matches with unit test default + if (acl && psAcl) + { + EXPECT_TRUE(strcmp((char*)acl->subject.id, (char*)psAcl->subject.id) == 0); + EXPECT_EQ(acl->resourcesLen, psAcl->resourcesLen); + for (size_t i = 0; i < acl->resourcesLen; i++) { - EXPECT_TRUE(memcmp(&(acl->subject), &(defaultAcl->subject), sizeof(OicUuid_t)) == 0); - EXPECT_EQ(acl->resourcesLen, defaultAcl->resourcesLen); - for (size_t i = 0; i < acl->resourcesLen; i++) - { - EXPECT_EQ(strlen(acl->resources[i]), strlen(defaultAcl->resources[i])); - EXPECT_TRUE( - memcmp(acl->resources[i], defaultAcl->resources[i], - strlen(acl->resources[i])) == 0); - } - EXPECT_EQ(acl->permission, defaultAcl->permission); + EXPECT_EQ(strlen(acl->resources[i]), strlen(psAcl->resources[i])); + EXPECT_TRUE(memcmp(acl->resources[i], psAcl->resources[i], + strlen(acl->resources[i])) == 0); } - - // Perform cleanup - DeleteACLList(acl); - DeleteACLList(defaultAcl); - OICFree(jsonStr); + EXPECT_EQ(acl->permission, psAcl->permission); } -} + DeleteACLList(psAcl); + DeleteACLList(acl); + DeInitACLResource(); + OICFree(payload); +} // 'POST' ACL tests TEST(ACLResourceTest, ACLPostTest) { - OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); - // Read an ACL from the file - char *jsonStr = ReadFile(ACL1_JSON_FILE_NAME); - if (jsonStr) - { - static OCPersistentStorage ps = OCPersistentStorage(); + uint8_t *payload = NULL; + size_t size = 0; - SetPersistentHandler(&ps, true); + ASSERT_TRUE(ReadCBORFile(ACL1_FILE_NAME, OIC_JSON_ACL_NAME, &payload, &size)); + ASSERT_TRUE(NULL != payload); - // Create Entity Handler POST request payload - ehReq.method = OC_REST_POST; - ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr); + OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size); + ASSERT_TRUE(NULL != securityPayload); - OCEntityHandlerResult ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_ERROR == ehRet); + static OCPersistentStorage ps = OCPersistentStorage(); + SetPersistentHandler(&ps, true); - // Convert JSON into OicSecAcl_t for verification - OicSecAcl_t * acl = JSONToAclBin(jsonStr); - EXPECT_TRUE(NULL != acl); + // Create Entity Handler POST request payload + OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); + ehReq.method = OC_REST_POST; + ehReq.payload = (OCPayload *) securityPayload; - // Verify if SRM contains ACL for the subject - OicSecAcl_t* savePtr = NULL; - const OicSecAcl_t* subjectAcl = GetACLResourceData(&(acl->subject), &savePtr); - EXPECT_TRUE(NULL != subjectAcl); + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); - // Perform cleanup - DeleteACLList(acl); - DeInitACLResource(); - OCPayloadDestroy(ehReq.payload); - OICFree(jsonStr); - } -} + OicSecAcl_t *acl = CBORPayloadToAcl(payload, size); + ASSERT_TRUE(NULL != acl); + + // Verify if SRM contains ACL for the subject + OicSecAcl_t *savePtr = NULL; + const OicSecAcl_t* subjectAcl = GetACLResourceData(&(acl->subject), &savePtr); + ASSERT_TRUE(NULL != subjectAcl); + // Perform cleanup + OICFree(payload); + OCPayloadDestroy((OCPayload *) securityPayload); + DeInitACLResource(); + DeleteACLList(acl); +} // GetACLResource tests TEST(ACLResourceTest, GetACLResourceTests) { - // gAcl is a pointer to the the global ACL used by SRM - extern OicSecAcl_t *gAcl; - // Read an ACL from the file - char *jsonStr = ReadFile(ACL1_JSON_FILE_NAME); - if (jsonStr) - { - gAcl = JSONToAclBin(jsonStr); - EXPECT_TRUE(NULL != gAcl); + static OCPersistentStorage ps = OCPersistentStorage(); + SetPersistentHandler(&ps, true); - // Verify that ACL file contains 2 ACE entries for 'WILDCARD' subject - const OicSecAcl_t* acl = NULL; - OicSecAcl_t* savePtr = NULL; - OicUuid_t subject = WILDCARD_SUBJECT_ID; - int count = 0; + uint8_t *payload = NULL; + size_t size = 0; - do - { - acl = GetACLResourceData(&subject, &savePtr); - count = (NULL != acl) ? count + 1 : count; - } while (acl != NULL); + ASSERT_TRUE(ReadCBORFile(ACL1_FILE_NAME, OIC_JSON_ACL_NAME, &payload, &size)); + ASSERT_TRUE(payload != NULL); - EXPECT_EQ(count, NUM_ACE_FOR_WILDCARD_IN_ACL1_JSON); + OicSecAcl_t *defaultPsAcl = CBORPayloadToAcl(payload, size); + ASSERT_TRUE(defaultPsAcl != NULL); - /* Perform cleanup */ - DeleteACLList(gAcl); - gAcl = NULL; - OICFree(jsonStr); - } + OicSecAcl_t *acl1 = NULL; + EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&acl1)); + ASSERT_TRUE(acl1 != NULL); + EXPECT_EQ(OC_STACK_OK, SetDefaultACL(acl1)); + + // Verify that ACL file contains 2 ACE entries for 'WILDCARD' subject + const OicSecAcl_t *acl = NULL; + OicSecAcl_t *savePtr = NULL; + OicUuid_t subject = WILDCARD_SUBJECT_ID; + int count = 0; + + do + { + acl = GetACLResourceData(&subject, &savePtr); + count = (NULL != acl) ? count + 1 : count; + } while (acl != NULL); + + EXPECT_EQ(count, NUM_ACE_FOR_WILDCARD_IN_ACL1_DAT); + + /* Perform cleanup */ + OICFree(payload); + DeleteACLList(defaultPsAcl); + DeInitACLResource(); } static OCStackResult populateAcl(OicSecAcl_t *acl, int numRsrc) { - OCStackResult ret = OC_STACK_ERROR; + OCStackResult ret = OC_STACK_ERROR; memcpy(acl->subject.id, "2222222222222222", sizeof(acl->subject.id)); - acl->resourcesLen = numRsrc; + acl->resourcesLen = (size_t)numRsrc; acl->resources = (char**)OICCalloc(acl->resourcesLen, sizeof(char*)); VERIFY_NON_NULL(TAG, acl->resources, ERROR); acl->resources[0] = (char*)OICMalloc(strlen("/a/led")+1); VERIFY_NON_NULL(TAG, acl->resources[0], ERROR); - OICStrcpy(acl->resources[0], sizeof(acl->resources[0]), "/a/led"); + OICStrcpy(acl->resources[0], strlen("/a/led")+1, "/a/led"); if(numRsrc == 2) { acl->resources[1] = (char*)OICMalloc(strlen("/a/fan")+1); VERIFY_NON_NULL(TAG, acl->resources[1], ERROR); - OICStrcpy(acl->resources[1], sizeof(acl->resources[1]), "/a/fan"); + OICStrcpy(acl->resources[1], strlen("/a/fan")+1, "/a/fan"); } acl->permission = 6; - acl->ownersLen = 1; - acl->owners = (OicUuid_t*)OICCalloc(acl->ownersLen, sizeof(OicUuid_t)); - VERIFY_NON_NULL(TAG, acl->owners, ERROR); - memcpy(acl->owners->id, "1111111111111111", sizeof(acl->owners->id)); + memcpy(acl->rownerID.id, "1111111111111111", sizeof(acl->rownerID.id)); ret = OC_STACK_OK; exit: @@ -237,158 +334,145 @@ exit: //'DELETE' ACL test TEST(ACLResourceTest, ACLDeleteWithSingleResourceTest) { - OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); - static OCPersistentStorage ps = OCPersistentStorage(); - char *jsonStr = NULL; + //Populate ACL OicSecAcl_t acl = OicSecAcl_t(); - OicSecAcl_t* savePtr = NULL; - const OicSecAcl_t* subjectAcl1 = NULL; - const OicSecAcl_t* subjectAcl2 = NULL; - OCEntityHandlerResult ehRet = OC_EH_ERROR; - char query[] = "sub=MjIyMjIyMjIyMjIyMjIyMg==;rsrc=/a/led"; + EXPECT_EQ(OC_STACK_OK, populateAcl(&acl, 1)); - SetPersistentHandler(&ps, true); + //GET CBOR POST payload + size_t size = 0; + uint8_t *payload = NULL; + EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(&acl, &payload, &size)); + ASSERT_TRUE(NULL != payload); - //Populate ACL - VERIFY_SUCCESS(TAG, (OC_STACK_OK == populateAcl(&acl, 1)), ERROR); + // Security Payload + OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size); + ASSERT_TRUE(NULL != securityPayload); - //GET json POST payload - jsonStr = BinToAclJSON(&acl); - VERIFY_NON_NULL(TAG, jsonStr, ERROR); + static OCPersistentStorage ps = OCPersistentStorage(); + SetPersistentHandler(&ps, true); // Create Entity Handler POST request payload + OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); + ehReq.payload = (OCPayload *) securityPayload; ehReq.method = OC_REST_POST; - ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr); - ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_ERROR == ehRet); + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); // Verify if SRM contains ACE for the subject - savePtr = NULL; - subjectAcl1 = GetACLResourceData(&acl.subject, &savePtr); - EXPECT_TRUE(NULL != subjectAcl1); + OicSecAcl_t* savePtr = NULL; + const OicSecAcl_t* subjectAcl1 = GetACLResourceData(&acl.subject, &savePtr); + ASSERT_TRUE(NULL != subjectAcl1); // Create Entity Handler DELETE request ehReq.method = OC_REST_DELETE; - ehReq.query = (char*)OICMalloc(strlen(query)+1); - VERIFY_NON_NULL(TAG, ehReq.query, ERROR); + char query[] = "subjectuuid=2222222222222222;resources=/a/led"; + ehReq.query = (char *)OICMalloc(strlen(query)+1); + ASSERT_TRUE(NULL != ehReq.query); OICStrcpy(ehReq.query, strlen(query)+1, query); - ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_ERROR == ehRet); + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); // Verify if SRM has deleted ACE for the subject savePtr = NULL; - subjectAcl2 = GetACLResourceData(&acl.subject, &savePtr); - EXPECT_TRUE(NULL == subjectAcl2); + const OicSecAcl_t* subjectAcl2 = GetACLResourceData(&acl.subject, &savePtr); + ASSERT_TRUE(NULL == subjectAcl2); -exit: // Perform cleanup - if(NULL != subjectAcl1) - { - DeInitACLResource(); - } - OCPayloadDestroy(ehReq.payload); + DeInitACLResource(); OICFree(ehReq.query); - OICFree(jsonStr); - + OCPayloadDestroy((OCPayload *)securityPayload); + OICFree(payload); } TEST(ACLResourceTest, ACLDeleteWithMultiResourceTest) { - OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); - static OCPersistentStorage ps = OCPersistentStorage(); + //Populate ACL OicSecAcl_t acl = OicSecAcl_t(); - char *jsonStr = NULL; - OicSecAcl_t* savePtr = NULL; - const OicSecAcl_t* subjectAcl1 = NULL; - const OicSecAcl_t* subjectAcl2 = NULL; - OCEntityHandlerResult ehRet = OC_EH_ERROR; - char query[] = "sub=MjIyMjIyMjIyMjIyMjIyMg==;rsrc=/a/led"; + EXPECT_EQ(OC_STACK_OK, populateAcl(&acl, 2)); - SetPersistentHandler(&ps, true); + //GET CBOR POST payload + size_t size = 0; + uint8_t *payload = NULL; + EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(&acl, &payload, &size)); + ASSERT_TRUE(NULL != payload); - //Populate ACL - VERIFY_SUCCESS(TAG, (OC_STACK_OK == populateAcl(&acl, 2)), ERROR); + // Security Payload + OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size); + ASSERT_TRUE(NULL!= securityPayload); - //GET json POST payload - jsonStr = BinToAclJSON(&acl); - VERIFY_NON_NULL(TAG, jsonStr, ERROR); + static OCPersistentStorage ps = OCPersistentStorage(); + SetPersistentHandler(&ps, true); // Create Entity Handler POST request payload + OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); ehReq.method = OC_REST_POST; - ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr); - ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_ERROR == ehRet); + ehReq.payload = (OCPayload *)securityPayload; + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); // Verify if SRM contains ACE for the subject with two resources - savePtr = NULL; - subjectAcl1 = GetACLResourceData(&acl.subject, &savePtr); - EXPECT_TRUE(NULL != subjectAcl1); - EXPECT_TRUE(subjectAcl1->resourcesLen == 2); + OicSecAcl_t* savePtr = NULL; + const OicSecAcl_t* subjectAcl1 = GetACLResourceData(&acl.subject, &savePtr); + ASSERT_TRUE(NULL != subjectAcl1); + EXPECT_EQ(2, subjectAcl1->resourcesLen); // Create Entity Handler DELETE request ehReq.method = OC_REST_DELETE; - ehReq.query = (char*)OICMalloc(strlen(query)+1); - VERIFY_NON_NULL(TAG, ehReq.query, ERROR); + char query[] = "subjectuuid=2222222222222222;resources=/a/led"; + ehReq.query = (char *)OICMalloc(strlen(query)+1); + ASSERT_TRUE(NULL != ehReq.query); OICStrcpy(ehReq.query, strlen(query)+1, query); - ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_ERROR == ehRet); + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); // Verify if SRM contains ACL for the subject but only with one resource savePtr = NULL; - subjectAcl2 = GetACLResourceData(&acl.subject, &savePtr); - EXPECT_TRUE(NULL != subjectAcl2); - EXPECT_TRUE(subjectAcl2->resourcesLen == 1); + const OicSecAcl_t* subjectAcl2 = GetACLResourceData(&acl.subject, &savePtr); + ASSERT_TRUE(NULL != subjectAcl2); + EXPECT_EQ(1, subjectAcl2->resourcesLen); -exit: // Perform cleanup - if(NULL != subjectAcl1) - { - DeInitACLResource(); - } - OCPayloadDestroy(ehReq.payload); + OCPayloadDestroy((OCPayload *)securityPayload); + DeInitACLResource(); OICFree(ehReq.query); - OICFree(jsonStr); + OICFree(payload); } //'GET' with query ACL test - TEST(ACLResourceTest, ACLGetWithQueryTest) { - OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); - static OCPersistentStorage ps = OCPersistentStorage(); + //Populate ACL OicSecAcl_t acl = OicSecAcl_t(); - char *jsonStr = NULL; - OCEntityHandlerResult ehRet = OC_EH_ERROR; - char query[] = "sub=MjIyMjIyMjIyMjIyMjIyMg==;rsrc=/a/led"; + EXPECT_EQ(OC_STACK_OK, populateAcl(&acl, 1)); - SetPersistentHandler(&ps, true); + //GET CBOR POST payload + size_t size = 0; + uint8_t *payload = NULL; + EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(&acl, &payload, &size)); + ASSERT_TRUE(NULL != payload); - //Populate ACL - VERIFY_SUCCESS(TAG, (OC_STACK_OK == populateAcl(&acl, 1)), ERROR); + // Security Payload + OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size); + ASSERT_TRUE(NULL != securityPayload); - //GET json POST payload - jsonStr = BinToAclJSON(&acl); - VERIFY_NON_NULL(TAG, jsonStr, ERROR); + static OCPersistentStorage ps = OCPersistentStorage(); + SetPersistentHandler(&ps, true); //Create Entity Handler POST request payload + OCEntityHandlerRequest ehReq = OCEntityHandlerRequest(); ehReq.method = OC_REST_POST; - ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr); - ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_ERROR == ehRet); + ehReq.payload = (OCPayload *)securityPayload; + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); //Create Entity Handler GET request wit query - ehReq.method = OC_REST_GET; + ehReq.method = OC_REST_GET; + char query[] = "subjectuuid=2222222222222222;resources=/a/led"; ehReq.query = (char*)OICMalloc(strlen(query)+1); - VERIFY_NON_NULL(TAG, ehReq.query, ERROR); + ASSERT_TRUE(NULL != ehReq.query); OICStrcpy(ehReq.query, strlen(query)+1, query); - ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq); - EXPECT_TRUE(OC_EH_OK == ehRet); + ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL); -exit: // Perform cleanup - OCPayloadDestroy(ehReq.payload); + OCPayloadDestroy((OCPayload *)securityPayload); + DeInitACLResource(); OICFree(ehReq.query); - OICFree(jsonStr); + OICFree(payload); }