resource/provisioning/unittests/OCProvisioningTest.cpp

   1 /* *****************************************************************
   2  *
   3  * Copyright 2015 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 <ocstack.h>
  22 #include <oic_malloc.h>
  23 #include <OCApi.h>
  24 #include <OCPlatform_impl.h>
  25 #include <oxmjustworks.h>
  26 #include <oxmrandompin.h>
  27 #include <OCProvisioningManager.h>
  28 #include <gtest/gtest.h>
  29
  30 #define TIMEOUT 5
  31
  32 namespace OCProvisioningTest
  33 {
  34     using namespace OC;
  35
  36     void resultCallback(PMResultList_t *result, int hasError)
  37     {
  38         (void)result;
  39         (void)hasError;
  40     }
  41
  42     TEST(ProvisionInitTest, TestWithEmptyPath)
  43     {
  44         std::string dbPath("");
  45         EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
  46     }
  47
  48     TEST(ProvisionInitTest, TestValidPath)
  49     {
  50         std::string dbPath("./dbPath");
  51         EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
  52     }
  53
  54     TEST(DiscoveryTest, SecureResource)
  55     {
  56         DeviceList_t list;
  57         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverSecureResource(TIMEOUT, "", CT_DEFAULT, list));
  58     }
  59
  60     TEST(DiscoveryTest, SecureResourceZeroTimeout)
  61     {
  62         DeviceList_t list;
  63         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverSecureResource(0, "", CT_DEFAULT, list));
  64     }
  65
  66     TEST(DiscoveryTest, UnownedDevices)
  67     {
  68         DeviceList_t list;
  69         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverUnownedDevices(TIMEOUT, list));
  70     }
  71
  72     TEST(DiscoveryTest, UnownedDevicesZeroTimeout)
  73     {
  74         DeviceList_t list;
  75         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverUnownedDevices(0, list));
  76     }
  77
  78     TEST(DiscoveryTest, OwnedDevices)
  79     {
  80         DeviceList_t list;
  81         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverOwnedDevices(TIMEOUT, list));
  82     }
  83
  84     TEST(DiscoveryTest, OwnedDevicesZeroTimeout)
  85     {
  86         DeviceList_t list;
  87         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverOwnedDevices(0, list));
  88     }
  89
  90     TEST(OwnershipTest, SetOwnershipTransferCBDataNull)
  91     {
  92         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
  93                     OIC_JUST_WORKS, NULL, NULL));
  94     }
  95
  96     TEST(OwnershipTest, SetOwnershipTransferCBData)
  97     {
  98         OTMCallbackData_t justWorksCBData;
  99         justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
 100         justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 101         justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 102         justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 103         EXPECT_EQ(OC_STACK_OK, OCSecure::setOwnerTransferCallbackData(OIC_JUST_WORKS,
 104                                         &justWorksCBData, NULL));
 105     }
 106
 107     TEST(OwnershipTest, SetOwnershipTransferCBDataInvalidType)
 108     {
 109         OTMCallbackData_t justWorksCBData;
 110         justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
 111         justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 112         justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 113         justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 114         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(OIC_OXM_COUNT,
 115                                         &justWorksCBData, NULL));
 116     }
 117
 118     TEST(OwnershipTest, SetOwnershipTransferCBDataNullInputPin)
 119     {
 120         OTMCallbackData_t pinBasedCBData;
 121         pinBasedCBData.loadSecretCB = InputPinCodeCallback;
 122         pinBasedCBData.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
 123         pinBasedCBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
 124         pinBasedCBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
 125         OTMSetOwnershipTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &pinBasedCBData);
 126
 127         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
 128                     OIC_RANDOM_DEVICE_PIN, &pinBasedCBData, NULL));
 129     }
 130
 131     TEST(OwnershipTest, OwnershipTransferNullCallback)
 132     {
 133         OCSecureResource device;
 134         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
 135     }
 136
 137     TEST(DeviceInfoTest, DevInfoFromNetwork)
 138     {
 139         DeviceList_t owned, unowned;
 140         EXPECT_EQ(OC_STACK_OK, OCSecure::getDevInfoFromNetwork(TIMEOUT,
 141                     owned, unowned));
 142     }
 143
 144     TEST(SetDisplayPinCBTest, SetDisplayPinCBTestNullCB)
 145     {
 146         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDisplayPinCB(nullptr));
 147     }
 148
 149     TEST(ProvisionAclTest, ProvisionAclTestNullAcl)
 150     {
 151         OCSecureResource device;
 152         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, resultCallback));
 153     }
 154
 155     TEST(ProvisionAclTest, ProvisionAclTestNullCallback)
 156     {
 157         OCSecureResource device;
 158         OicSecAcl_t *acl = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 159         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionACL(acl, nullptr));
 160         OICFree(acl);
 161     }
 162
 163     TEST(ProvisionAclTest, ProvisionAclTestNullCallbackNUllAcl)
 164     {
 165         OCSecureResource device;
 166         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, nullptr));
 167     }
 168
 169     TEST(ProvisionCredTest, ProvisionCredTestNullCallback)
 170     {
 171         OCSecureResource device, dev2;
 172         Credential cred;
 173         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionCredentials(cred, dev2, nullptr));
 174     }
 175
 176     TEST(ProvisionPairwiseTest, ProvisionPairwiseTestNullCallback)
 177     {
 178         OCSecureResource device, dev2;
 179         Credential cred;
 180         OicSecAcl_t *acl1 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 181         OicSecAcl_t *acl2 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 182         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPairwiseDevices(cred, acl1,
 183                     dev2, acl2, nullptr));
 184         OICFree(acl1);
 185         OICFree(acl2);
 186     }
 187
 188     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullPconf)
 189     {
 190         OCSecureResource device;
 191         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, resultCallback));
 192     }
 193
 194     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallback)
 195     {
 196         OCSecureResource device;
 197         OicSecPconf_t *pconf = (OicSecPconf_t *)OICCalloc(1,sizeof(OicSecPconf_t));
 198         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionDirectPairing(pconf, nullptr));
 199         OICFree(pconf);
 200     }
 201
 202     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallbackNUllPconf)
 203     {
 204         OCSecureResource device;
 205         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, nullptr));
 206     }
 207 }