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 <srmutility.h>
  28 #include <OCProvisioningManager.hpp>
  29 #include <gtest/gtest.h>
  30
  31 #define TIMEOUT 5
  32
  33 namespace OCProvisioningTest
  34 {
  35     using namespace OC;
  36
  37     void resultCallback(PMResultList_t *result, int hasError)
  38     {
  39         (void)result;
  40         (void)hasError;
  41     }
  42
  43     TEST(ProvisionInitTest, TestWithEmptyPath)
  44     {
  45         std::string dbPath("");
  46         EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
  47     }
  48
  49     TEST(ProvisionInitTest, TestValidPath)
  50     {
  51         std::string dbPath("./dbPath");
  52         EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
  53     }
  54
  55     TEST(DiscoveryTest, SecureResource)
  56     {
  57         std::shared_ptr< OC::OCSecureResource > secureResource;
  58         OicUuid_t uuid;
  59         ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
  60
  61         EXPECT_EQ(OC_STACK_TIMEOUT, OCSecure::discoverSingleDevice(TIMEOUT, &uuid, secureResource));
  62     }
  63
  64     TEST(DiscoveryTest, SecureResourceZeroTimeout)
  65     {
  66         std::shared_ptr< OC::OCSecureResource > secureResource;
  67         OicUuid_t uuid;
  68         ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
  69
  70         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverSingleDevice(0, &uuid, secureResource));
  71     }
  72
  73     TEST(DiscoveryTest, UnownedDevices)
  74     {
  75         DeviceList_t list;
  76         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverUnownedDevices(TIMEOUT, list));
  77     }
  78
  79     TEST(DiscoveryTest, UnownedDevicesZeroTimeout)
  80     {
  81         DeviceList_t list;
  82         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverUnownedDevices(0, list));
  83     }
  84
  85 #ifdef MULTIPLE_OWNER
  86     TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevices)
  87     {
  88         DeviceList_t list;
  89         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnerEnabledDevices(TIMEOUT, list));
  90     }
  91
  92     TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevicesZeroTimeOut)
  93     {
  94         DeviceList_t list;
  95         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnerEnabledDevices(0, list));
  96     }
  97
  98     TEST(MOTDiscoveryTest, MultipleOwnedDevices)
  99     {
 100         DeviceList_t list;
 101         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnedDevices(TIMEOUT, list));
 102     }
 103
 104     TEST(MOTDiscoveryTest, MultipleOwnedDevicesZeroTimeOut)
 105     {
 106         DeviceList_t list;
 107         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnedDevices(0, list));
 108     }
 109 #endif
 110
 111     TEST(DiscoveryTest, OwnedDevices)
 112     {
 113         DeviceList_t list;
 114         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverOwnedDevices(TIMEOUT, list));
 115     }
 116
 117     TEST(DiscoveryTest, OwnedDevicesZeroTimeout)
 118     {
 119         DeviceList_t list;
 120         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverOwnedDevices(0, list));
 121     }
 122
 123     TEST(OwnershipTest, OwnershipTransferNullCallback)
 124     {
 125         OCSecureResource device;
 126         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
 127     }
 128
 129 #ifdef MULTIPLE_OWNER
 130     TEST(MOTOwnershipTest, MOTOwnershipTransferNullCallback)
 131     {
 132         OCSecureResource device;
 133         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doMultipleOwnershipTransfer(nullptr));
 134     }
 135
 136     TEST(selectMOTMethodTest, selectMOTMethodNullCallback)
 137     {
 138         OCSecureResource device;
 139         const OicSecOxm_t stsecOxm = OIC_PRECONFIG_PIN;
 140         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.selectMOTMethod(stsecOxm, NULL));
 141     }
 142
 143     TEST(changeMOTModeTest, changeMOTModeNullCallback)
 144     {
 145         OCSecureResource device;
 146         const OicSecMomType_t momType = OIC_MULTIPLE_OWNER_ENABLE;
 147         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.changeMOTMode(momType, NULL));
 148     }
 149
 150     TEST(addPreconfigPINTest, addPreconfigPINNullPin)
 151     {
 152         OCSecureResource device;
 153         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.addPreconfigPIN(NULL, 0));
 154     }
 155
 156     TEST(provisionPreconfPinTest, provisionPreconfPinNullCallback)
 157     {
 158         OCSecureResource device;
 159         const char *pin = "test";
 160         size_t PinLength = 4;
 161         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPreconfPin(pin, PinLength, NULL));
 162     }
 163
 164     TEST(isMOTEnabledTest, isMOTEnabledWithoutDeviceInst)
 165     {
 166         OCSecureResource device;
 167         EXPECT_EQ(false, device.isMOTEnabled());
 168     }
 169
 170     TEST(isMOTSupportedTest, isMOTSupportedWithoutDeviceInst)
 171     {
 172         OCSecureResource device;
 173         EXPECT_EQ(false, device.isMOTSupported());
 174     }
 175
 176     TEST(getMOTMethodTest, getMOTMethodNullOxM)
 177     {
 178         OCSecureResource device;
 179         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.getMOTMethod(NULL));
 180     }
 181 #endif
 182
 183     TEST(DeviceInfoTest, DevInfoFromNetwork)
 184     {
 185         DeviceList_t owned, unowned;
 186         EXPECT_EQ(OC_STACK_OK, OCSecure::getDevInfoFromNetwork(TIMEOUT,
 187                     owned, unowned));
 188     }
 189
 190     TEST(SetDisplayPinCBTest, SetDisplayPinCBTestNullCB)
 191     {
 192         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDisplayPinCB(nullptr));
 193     }
 194
 195     TEST(ProvisionAclTest, ProvisionAclTestNullAcl)
 196     {
 197         OCSecureResource device;
 198         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, resultCallback));
 199     }
 200
 201     TEST(ProvisionAclTest, ProvisionAclTestNullCallback)
 202     {
 203         OCSecureResource device;
 204         OicSecAcl_t *acl = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 205         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionACL(acl, nullptr));
 206         OICFree(acl);
 207     }
 208
 209     TEST(ProvisionAclTest, ProvisionAclTestNullCallbackNUllAcl)
 210     {
 211         OCSecureResource device;
 212         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, nullptr));
 213     }
 214
 215     TEST(ProvisionCredTest, ProvisionCredTestNullCallback)
 216     {
 217         OCSecureResource device, dev2;
 218         Credential cred;
 219         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionCredentials(cred, dev2, nullptr));
 220     }
 221
 222     TEST(ProvisionPairwiseTest, ProvisionPairwiseTestNullCallback)
 223     {
 224         OCSecureResource device, dev2;
 225         Credential cred;
 226         OicSecAcl_t *acl1 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 227         OicSecAcl_t *acl2 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 228         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPairwiseDevices(cred, acl1,
 229                     dev2, acl2, nullptr));
 230         OICFree(acl1);
 231         OICFree(acl2);
 232     }
 233
 234     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullPconf)
 235     {
 236         OCSecureResource device;
 237         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, resultCallback));
 238     }
 239
 240     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallback)
 241     {
 242         OCSecureResource device;
 243         OicSecPconf_t *pconf = (OicSecPconf_t *)OICCalloc(1,sizeof(OicSecPconf_t));
 244         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionDirectPairing(pconf, nullptr));
 245         OICFree(pconf);
 246     }
 247
 248     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallbackNUllPconf)
 249     {
 250         OCSecureResource device;
 251         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, nullptr));
 252     }
 253
 254 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 255     TEST(setDeviceIdSeed, NullParam)
 256     {
 257         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(NULL, 0));
 258     }
 259
 260     TEST(setDeviceIdSeed, InvalidParam)
 261     {
 262         uint8_t seed[1024] = {0};
 263
 264         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(seed, 0));
 265         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(seed, sizeof(seed)));
 266     }
 267
 268     TEST(setDeviceIdSeed, ValidValue)
 269     {
 270         uint8_t seed[16] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 271                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
 272         EXPECT_EQ(OC_STACK_OK, OCSecure::setDeviceIdSeed(seed, sizeof(seed)));
 273     }
 274 #endif // __WITH_DTLS__ || __WITH_TLS__
 275 }