1 //******************************************************************
3 // Copyright 2016 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include <gtest/gtest.h>
22 #include <HippoMocks/hippomocks.h>
25 #include <condition_variable>
29 #include "ESMediatorSimulator.h"
30 #include "easysetup.h"
36 std::atomic_bool g_isStartedStack(false);
38 std::chrono::milliseconds g_waitForResponse(1000);
40 std::condition_variable responseCon;
41 std::mutex mutexForCondition;
43 ESMediatorSimulator g_mediatorSimul;
46 class TestWithMock: public testing::Test
52 virtual ~TestWithMock() noexcept(noexcept(std::declval<Test>().~Test()))
56 virtual void TearDown()
70 class EasysetupEnrolleeTest : public TestWithMock
73 EasysetupEnrolleeTest() = default;
74 ~EasysetupEnrolleeTest() = default;
76 static void discoveredResource(std::shared_ptr<OC::OCResource>)
78 std::cout << __func__ << std::endl;
81 static void onGetStatus(std::shared_ptr< GetEnrolleeStatus >)
83 std::cout << __func__ << std::endl;
86 static void onGetConfiguration(std::shared_ptr< GetConfigurationStatus >)
88 std::cout << __func__ << std::endl;
91 static void onGetWifiRsrc(const OCRepresentation& )
93 std::cout << __func__ << std::endl;
96 static void onGetCloudRsrc(const OCRepresentation& )
98 std::cout << __func__ << std::endl;
101 static void onGetDeviceConf(const OCRepresentation& )
103 std::cout << __func__ << std::endl;
106 static void onPutRequest(const OCRepresentation& )
108 std::cout << __func__ << std::endl;
111 static void deviceProvisioningStatusCallback(std::shared_ptr< DevicePropProvisioningStatus >)
113 std::cout << __func__ << std::endl;
116 static void cloudProvisioningStatusCallback(std::shared_ptr< CloudPropProvisioningStatus >)
118 std::cout << __func__ << std::endl;
121 static void WiFiProvCbInApp(ESWiFiProvData *)
123 std::cout << __func__ << std::endl;
126 static void DevConfProvCbInApp(ESDevConfProvData *)
128 std::cout << __func__ << std::endl;
131 static void CloudDataCbInApp(ESCloudProvData *)
133 std::cout << __func__ << std::endl;
136 ESResult startEnrollee()
138 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
140 ES_DEVCONF_RESOURCE);
141 ESProvisioningCallbacks callbacks;
142 callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
143 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
144 callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
146 return ESInitEnrollee(false, resourcemMask, callbacks);
149 ESResult startEnrolleeWithInvalidRsrcMask()
151 ESProvisioningCallbacks callbacks;
152 callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
153 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
154 callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
156 return ESInitEnrollee(false, (ESResourceMask)0, callbacks);
159 ESResult setDeviceProperty()
161 ESDeviceProperty deviceProperty = {
162 {{WIFI_11G, WiFi_EOF}, WIFI_5G}, {"Test Device", "Test Model Number"}
165 return ESSetDeviceProperty(&deviceProperty);
168 ESResult setCallabckForUserDataNULL()
170 return ESSetCallbackForUserdata(NULL, NULL);
177 TestWithMock::SetUp();
179 if (g_isStartedStack == false)
181 if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
183 printf("OCStack init error!!\n");
187 g_isStartedStack = true;
193 TestWithMock::TearDown();
198 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeSuccess)
200 ESResult ret = startEnrollee();
201 EXPECT_EQ(ret, ES_OK);
202 ESTerminateEnrollee();
205 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedInvalidRsrcMask)
207 ESResult ret = startEnrolleeWithInvalidRsrcMask();
208 EXPECT_EQ(ret, ES_ERROR);
209 ESTerminateEnrollee();
212 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
214 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
216 ES_DEVCONF_RESOURCE);
217 ESProvisioningCallbacks callbacks;
218 callbacks.WiFiProvCb = NULL;
219 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
220 callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
222 ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
223 EXPECT_EQ(ret, ES_ERROR);
224 ESTerminateEnrollee();
227 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
229 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
231 ES_DEVCONF_RESOURCE);
232 ESProvisioningCallbacks callbacks;
233 callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
234 callbacks.DevConfProvCb = NULL;
235 callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
237 ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
238 EXPECT_EQ(ret, ES_ERROR);
239 ESTerminateEnrollee();
242 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByCloudCbIsNull)
244 ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
246 ES_DEVCONF_RESOURCE);
247 ESProvisioningCallbacks callbacks;
248 callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
249 callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
250 callbacks.CloudDataProvCb = NULL;
252 ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
253 EXPECT_EQ(ret, ES_ERROR);
254 ESTerminateEnrollee();
257 TEST_F(EasysetupEnrolleeTest, FindProvisioningResourceAtEnrolleeWithSuccess)
259 mocks.ExpectCallFunc(discoveredResource).Do(
260 [](std::shared_ptr<OC::OCResource> resource)
264 std::cout<<"DISCOVERED Resource:"<<std::endl;
265 // Get the resource host address
266 std::string uri = resource->uri();
267 std::cout << "\tURI of the resource: " << uri << std::endl;
268 } catch (OCException &e)
270 std::cout << e.reason() << std::endl;
275 ESResult ret = startEnrollee();
277 g_mediatorSimul.discoverRemoteEnrollee(discoveredResource);
279 std::unique_lock< std::mutex > lock{ mutexForCondition };
280 responseCon.wait_for(lock, g_waitForResponse);
282 EXPECT_EQ(ret, ES_OK);
284 ESTerminateEnrollee();
287 TEST_F(EasysetupEnrolleeTest, SetDevicePropertyWithSuccess)
289 ESResult ret = startEnrollee();
290 ret = setDeviceProperty();
291 EXPECT_EQ(ret, ES_OK);
292 ESTerminateEnrollee();
295 TEST_F(EasysetupEnrolleeTest, SetProvStatusWithSuccess)
297 ESResult ret = startEnrollee();
298 ret = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
299 EXPECT_EQ(ret, ES_OK);
300 ESTerminateEnrollee();
303 TEST_F(EasysetupEnrolleeTest, SetErrorCodeWithSuccess)
305 ESResult ret = startEnrollee();
306 ret = ESSetErrorCode(ES_ERRCODE_PW_WRONG);
307 EXPECT_EQ(ret, ES_OK);
308 ESTerminateEnrollee();
311 TEST_F(EasysetupEnrolleeTest, DevicePropertyIsWellConstructedInResponsePayload)
313 bool isWellConstructed = false;
314 mocks.ExpectCallFunc(onGetConfiguration).Do(
315 [& isWellConstructed](std::shared_ptr< GetConfigurationStatus > status)
317 if(status->getESResult() == ES_OK)
319 EnrolleeConf conf = status->getEnrolleeConf();
320 if(conf.getWiFiModes().at(0) == WIFI_11G &&
321 conf.getWiFiFreq() == WIFI_5G &&
322 !strcmp(conf.getDeviceName().c_str(), "Test Device"))
324 isWellConstructed = true;
328 ESResult ret = startEnrollee();
329 ret = setDeviceProperty();
331 g_mediatorSimul.getConfiguration(onGetConfiguration);
333 std::unique_lock< std::mutex > lock{ mutexForCondition };
334 responseCon.wait_for(lock, g_waitForResponse);
336 EXPECT_EQ(ret, ES_OK);
338 ESTerminateEnrollee();
341 TEST_F(EasysetupEnrolleeTest, ProvisioningPropertiesIsWellConstructedInResponsePayload)
343 bool isWellConstructed = false;
344 mocks.ExpectCallFunc(onGetStatus).Do(
345 [& isWellConstructed](std::shared_ptr< GetEnrolleeStatus > status)
347 if(status->getESResult() == ES_OK)
349 EnrolleeStatus enrolleeStatus = status->getEnrolleeStatus();
352 if(enrolleeStatus.getProvStatus() == ES_STATE_CONNECTED_TO_ENROLLER &&
353 enrolleeStatus.getLastErrCode() == ES_ERRCODE_NO_INTERNETCONNECTION)
355 isWellConstructed = true;
359 ESResult ret = startEnrollee();
360 ret = setDeviceProperty();
361 ret = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
362 ret = ESSetErrorCode(ES_ERRCODE_NO_INTERNETCONNECTION);
364 g_mediatorSimul.getStatus(onGetStatus);
366 std::unique_lock< std::mutex > lock{ mutexForCondition };
367 responseCon.wait_for(lock, g_waitForResponse);
369 EXPECT_EQ(ret, ES_OK);
371 ESTerminateEnrollee();
374 TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
376 int cntForReceivedCallbackWithSuccess = 0;
378 mocks.OnCallFunc(deviceProvisioningStatusCallback).Do(
379 [& cntForReceivedCallbackWithSuccess](std::shared_ptr< DevicePropProvisioningStatus > status)
381 if(status->getESResult() == ES_OK)
382 cntForReceivedCallbackWithSuccess++;
385 mocks.OnCallFunc(WiFiProvCbInApp).Do(
386 [& cntForReceivedCallbackWithSuccess](ESWiFiProvData *data)
388 if(!strcmp(data->ssid, "Iotivity_SSID") &&
389 !strcmp(data->pwd, "Iotivity_PWD") &&
390 data->authtype == WPA2_PSK &&
391 data->enctype == TKIP_AES)
393 cntForReceivedCallbackWithSuccess++;
396 mocks.OnCallFunc(DevConfProvCbInApp).Do(
397 [& cntForReceivedCallbackWithSuccess](ESDevConfProvData *data)
399 if(!strcmp(data->language, "korean") &&
400 !strcmp(data->country, "Korea"))
402 cntForReceivedCallbackWithSuccess++;
408 g_mediatorSimul.provisionDeviceProperties(deviceProvisioningStatusCallback);
410 std::unique_lock< std::mutex > lock{ mutexForCondition };
411 responseCon.wait_for(lock, g_waitForResponse);
413 EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
415 ESTerminateEnrollee();
418 TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
420 int cntForReceivedCallbackWithSuccess = 0;
422 mocks.OnCallFunc(cloudProvisioningStatusCallback).Do(
423 [& cntForReceivedCallbackWithSuccess](std::shared_ptr< CloudPropProvisioningStatus > status)
426 if(status->getESResult() == ES_OK || status->getESResult() == ES_FOUND_ENROLLEE)
428 cntForReceivedCallbackWithSuccess++;
432 mocks.OnCallFunc(CloudDataCbInApp).Do(
433 [& cntForReceivedCallbackWithSuccess](ESCloudProvData *data)
435 if(!strcmp(data->authCode, "authCode") &&
436 !strcmp(data->authProvider, "authProvider") &&
437 !strcmp(data->ciServer, "ciServer"))
439 cntForReceivedCallbackWithSuccess++;
445 g_mediatorSimul.provisionCloudProperties(cloudProvisioningStatusCallback);
447 std::unique_lock< std::mutex > lock{ mutexForCondition };
448 responseCon.wait_for(lock, g_waitForResponse);
450 EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
452 ESTerminateEnrollee();
455 TEST_F(EasysetupEnrolleeTest, GetWifiRsrcTest)
457 bool isRepFlag = false;
458 mocks.ExpectCallFunc(onGetWifiRsrc).Do(
459 [& isRepFlag](const OCRepresentation& /*rep*/)
465 ESResult ret = startEnrollee();
466 g_mediatorSimul.getWifiRsrc(onGetWifiRsrc);
468 std::unique_lock< std::mutex > lock{ mutexForCondition };
469 responseCon.wait_for(lock, g_waitForResponse);
471 EXPECT_EQ(ret, ES_OK);
473 ESTerminateEnrollee();
476 TEST_F(EasysetupEnrolleeTest, GetCloudRsrcTest)
478 bool isRepFlag = false;
479 mocks.ExpectCallFunc(onGetCloudRsrc).Do(
480 [& isRepFlag](const OCRepresentation& /*rep*/)
485 ESResult ret = startEnrollee();
486 g_mediatorSimul.getCloudRsrc(onGetCloudRsrc);
488 std::unique_lock< std::mutex > lock{ mutexForCondition };
489 responseCon.wait_for(lock, g_waitForResponse);
491 EXPECT_EQ(ret, ES_OK);
493 ESTerminateEnrollee();
496 TEST_F(EasysetupEnrolleeTest, GetDevConfTest)
498 bool isRepFlag = false;
499 mocks.ExpectCallFunc(onGetDeviceConf).Do(
500 [& isRepFlag](const OCRepresentation& /*rep*/)
505 ESResult ret = startEnrollee();
506 ret = setDeviceProperty();
508 g_mediatorSimul.getDevConfiguration(onGetDeviceConf);
510 std::unique_lock< std::mutex > lock{ mutexForCondition };
511 responseCon.wait_for(lock, g_waitForResponse);
513 EXPECT_EQ(ret, ES_OK);
515 ESTerminateEnrollee();
518 TEST_F(EasysetupEnrolleeTest, PutRequestTest)
520 bool isRepFlag = false;
521 mocks.ExpectCallFunc(onPutRequest).Do(
522 [& isRepFlag](const OCRepresentation& /*rep*/)
527 ESResult ret = startEnrollee();
529 g_mediatorSimul.putProvRsrc(onPutRequest);
531 std::unique_lock< std::mutex > lock{ mutexForCondition };
532 responseCon.wait_for(lock, g_waitForResponse);
534 EXPECT_EQ(ret, ES_OK);
536 ESTerminateEnrollee();
539 TEST_F(EasysetupEnrolleeTest, ESSetCallabckForUserDataFailed)
541 ESResult ret = setCallabckForUserDataNULL();
542 EXPECT_EQ(ret, ES_ERROR);
543 ESTerminateEnrollee();