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_OK, 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     TEST(DiscoveryTest, OwnedDevices)
  86     {
  87         DeviceList_t list;
  88         EXPECT_EQ(OC_STACK_OK, OCSecure::discoverOwnedDevices(TIMEOUT, list));
  89     }
  90
  91     TEST(DiscoveryTest, OwnedDevicesZeroTimeout)
  92     {
  93         DeviceList_t list;
  94         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverOwnedDevices(0, list));
  95     }
  96
  97     TEST(OwnershipTest, SetOwnershipTransferCBDataNull)
  98     {
  99         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
 100                     OIC_JUST_WORKS, NULL, NULL));
 101     }
 102
 103     TEST(OwnershipTest, SetOwnershipTransferCBData)
 104     {
 105         OTMCallbackData_t justWorksCBData;
 106         justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
 107         justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 108         justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 109         justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 110         EXPECT_EQ(OC_STACK_OK, OCSecure::setOwnerTransferCallbackData(OIC_JUST_WORKS,
 111                                         &justWorksCBData, NULL));
 112     }
 113
 114     TEST(OwnershipTest, SetOwnershipTransferCBDataInvalidType)
 115     {
 116         OTMCallbackData_t justWorksCBData;
 117         justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
 118         justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 119         justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 120         justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 121         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(OIC_OXM_COUNT,
 122                                         &justWorksCBData, NULL));
 123     }
 124
 125     TEST(OwnershipTest, SetOwnershipTransferCBDataNullInputPin)
 126     {
 127         OTMCallbackData_t pinBasedCBData;
 128         pinBasedCBData.loadSecretCB = InputPinCodeCallback;
 129         pinBasedCBData.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
 130         pinBasedCBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
 131         pinBasedCBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
 132         OTMSetOwnershipTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &pinBasedCBData);
 133
 134         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
 135                     OIC_RANDOM_DEVICE_PIN, &pinBasedCBData, NULL));
 136     }
 137
 138     TEST(OwnershipTest, OwnershipTransferNullCallback)
 139     {
 140         OCSecureResource device;
 141         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
 142     }
 143
 144     TEST(DeviceInfoTest, DevInfoFromNetwork)
 145     {
 146         DeviceList_t owned, unowned;
 147         EXPECT_EQ(OC_STACK_OK, OCSecure::getDevInfoFromNetwork(TIMEOUT,
 148                     owned, unowned));
 149     }
 150
 151     TEST(SetDisplayPinCBTest, SetDisplayPinCBTestNullCB)
 152     {
 153         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDisplayPinCB(nullptr));
 154     }
 155
 156     TEST(ProvisionAclTest, ProvisionAclTestNullAcl)
 157     {
 158         OCSecureResource device;
 159         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, resultCallback));
 160     }
 161
 162     TEST(ProvisionAclTest, ProvisionAclTestNullCallback)
 163     {
 164         OCSecureResource device;
 165         OicSecAcl_t *acl = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 166         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionACL(acl, nullptr));
 167         OICFree(acl);
 168     }
 169
 170     TEST(ProvisionAclTest, ProvisionAclTestNullCallbackNUllAcl)
 171     {
 172         OCSecureResource device;
 173         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, nullptr));
 174     }
 175
 176     TEST(ProvisionCredTest, ProvisionCredTestNullCallback)
 177     {
 178         OCSecureResource device, dev2;
 179         Credential cred;
 180         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionCredentials(cred, dev2, nullptr));
 181     }
 182
 183     TEST(ProvisionPairwiseTest, ProvisionPairwiseTestNullCallback)
 184     {
 185         OCSecureResource device, dev2;
 186         Credential cred;
 187         OicSecAcl_t *acl1 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 188         OicSecAcl_t *acl2 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
 189         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPairwiseDevices(cred, acl1,
 190                     dev2, acl2, nullptr));
 191         OICFree(acl1);
 192         OICFree(acl2);
 193     }
 194
 195     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullPconf)
 196     {
 197         OCSecureResource device;
 198         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, resultCallback));
 199     }
 200
 201     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallback)
 202     {
 203         OCSecureResource device;
 204         OicSecPconf_t *pconf = (OicSecPconf_t *)OICCalloc(1,sizeof(OicSecPconf_t));
 205         EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionDirectPairing(pconf, nullptr));
 206         OICFree(pconf);
 207     }
 208
 209     TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallbackNUllPconf)
 210     {
 211         OCSecureResource device;
 212         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, nullptr));
 213     }
 214 }