replace : iotivity -> iotivity-sec

[platform/upstream/iotivity.git] / service / easy-setup / enrollee / unittests / ESEnrolleeTest.cpp

diff --git a/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp b/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
index 6232bce..b041d1f 100755 (executable)
--- a/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
+++ b/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
@@ -88,6 +88,26 @@ public:
         std::cout << __func__ << std::endl;
     }
 
+    static void onGetWifiRsrc(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
+    static void onGetCloudRsrc(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
+    static void onGetDeviceConf(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
+    static void onPutRequest(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
     static void deviceProvisioningStatusCallback(std::shared_ptr< DevicePropProvisioningStatus >)
     {
         std::cout << __func__ << std::endl;
@@ -98,34 +118,44 @@ public:
         std::cout << __func__ << std::endl;
     }
 
-    static void WiFiProvCbInApp(ESWiFiProvData *)
+    static void WiFiConfProvCbInApp(ESWiFiConfData *)
     {
         std::cout << __func__ << std::endl;
     }
 
-    static void DevConfProvCbInApp(ESDevConfProvData *)
+    static void DevConfProvCbInApp(ESDevConfData *)
     {
         std::cout << __func__ << std::endl;
     }
 
-    static void CloudDataCbInApp(ESCloudProvData *)
+    static void CoapCloudConfCbInApp(ESCoapCloudConfData *)
     {
         std::cout << __func__ << std::endl;
     }
 
     ESResult startEnrollee()
     {
-        ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+        ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
         ESProvisioningCallbacks callbacks;
-        callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
+        callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
         callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
-        callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
+        callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 
         return ESInitEnrollee(false, resourcemMask, callbacks);
     }
 
+    ESResult startEnrolleeWithInvalidRsrcMask()
+    {
+        ESProvisioningCallbacks callbacks;
+        callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
+        callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
+        callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
+
+        return ESInitEnrollee(false, (ESResourceMask)0, callbacks);
+    }
+
     ESResult setDeviceProperty()
     {
         ESDeviceProperty deviceProperty = {
@@ -135,6 +165,11 @@ public:
         return ESSetDeviceProperty(&deviceProperty);
     }
 
+    ESResult setCallabckForUserDataNULL()
+    {
+        return ESSetCallbackForUserdata(NULL, NULL);
+    }
+
 protected:
 
     void SetUp()
@@ -167,15 +202,22 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeSuccess)
     ESTerminateEnrollee();
 }
 
+TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedInvalidRsrcMask)
+{
+    ESResult ret = startEnrolleeWithInvalidRsrcMask();
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
 {
-    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
     ESProvisioningCallbacks callbacks;
-    callbacks.WiFiProvCb = NULL;
+    callbacks.WiFiConfProvCb = NULL;
     callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
-    callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
+    callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 
     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
     EXPECT_EQ(ret, ES_ERROR);
@@ -184,13 +226,13 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
 
 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
 {
-    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
     ESProvisioningCallbacks callbacks;
-    callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
+    callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
     callbacks.DevConfProvCb = NULL;
-    callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
+    callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 
     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
     EXPECT_EQ(ret, ES_ERROR);
@@ -199,13 +241,13 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
 
 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByCloudCbIsNull)
 {
-    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
     ESProvisioningCallbacks callbacks;
-    callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
+    callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
     callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
-    callbacks.CloudDataProvCb = NULL;
+    callbacks.CoapCloudConfProvCb = NULL;
 
     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
     EXPECT_EQ(ret, ES_ERROR);
@@ -340,8 +382,8 @@ TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
                cntForReceivedCallbackWithSuccess++;
         });
 
-    mocks.OnCallFunc(WiFiProvCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESWiFiProvData *data)
+    mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
+        [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
         {
             if(!strcmp(data->ssid, "Iotivity_SSID") &&
                 !strcmp(data->pwd, "Iotivity_PWD") &&
@@ -351,15 +393,6 @@ TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
                 cntForReceivedCallbackWithSuccess++;
             }
         });
-    mocks.OnCallFunc(DevConfProvCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESDevConfProvData *data)
-        {
-            if(!strcmp(data->language, "korean") &&
-                !strcmp(data->country, "Korea"))
-            {
-                cntForReceivedCallbackWithSuccess++;
-            }
-        });
 
     startEnrollee();
 
@@ -368,7 +401,7 @@ TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
     std::unique_lock< std::mutex > lock{ mutexForCondition };
     responseCon.wait_for(lock, g_waitForResponse);
 
-    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
+    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
 
     ESTerminateEnrollee();
 }
@@ -380,15 +413,14 @@ TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
     mocks.OnCallFunc(cloudProvisioningStatusCallback).Do(
         [& cntForReceivedCallbackWithSuccess](std::shared_ptr< CloudPropProvisioningStatus > status)
         {
-            // Will called twice
             if(status->getESResult() == ES_OK)
             {
                cntForReceivedCallbackWithSuccess++;
             }
         });
 
-    mocks.OnCallFunc(CloudDataCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESCloudProvData *data)
+    mocks.OnCallFunc(CoapCloudConfCbInApp).Do(
+        [& cntForReceivedCallbackWithSuccess](ESCoapCloudConfData *data)
         {
             if(!strcmp(data->authCode, "authCode") &&
                 !strcmp(data->authProvider, "authProvider") &&
@@ -405,9 +437,98 @@ TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
     std::unique_lock< std::mutex > lock{ mutexForCondition };
     responseCon.wait_for(lock, g_waitForResponse);
 
-    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
+    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, GetWifiRsrcTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onGetWifiRsrc).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+    g_mediatorSimul.getWifiRsrc(onGetWifiRsrc);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
 
     ESTerminateEnrollee();
 }
 
+TEST_F(EasysetupEnrolleeTest, GetCloudRsrcTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onGetCloudRsrc).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+    g_mediatorSimul.getCloudRsrc(onGetCloudRsrc);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, GetDevConfTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onGetDeviceConf).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+    ret = setDeviceProperty();
+
+    g_mediatorSimul.getDevConfiguration(onGetDeviceConf);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
 
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, PutRequestTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onPutRequest).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+
+    g_mediatorSimul.putProvRsrc(onPutRequest);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSetCallabckForUserDataFailed)
+{
+    ESResult ret = setCallabckForUserDataNULL();
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}