diff --git a/.github/workflows/gdbus_proxy_L1_test.yml b/.github/workflows/gdbus_proxy_L1_test.yml index 7d605b4b..242ca6bd 100644 --- a/.github/workflows/gdbus_proxy_L1_test.yml +++ b/.github/workflows/gdbus_proxy_L1_test.yml @@ -71,7 +71,7 @@ jobs: if: steps.cache.outputs.cache-hit != 'true' run: | cd ${{github.workspace}}/Thunder - git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/Remove-SmartLinkType.patch + git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/SubscribeStub.patch - name: Build ThunderTools if: steps.cache.outputs.cache-hit != 'true' diff --git a/.github/workflows/legacy_L1_L2_test.yml b/.github/workflows/legacy_L1_L2_test.yml new file mode 100644 index 00000000..a735bfdf --- /dev/null +++ b/.github/workflows/legacy_L1_L2_test.yml @@ -0,0 +1,171 @@ +name: legacy_l1_l2_tests + +on: + push: + branches: [ main, develop, 'support/**', 'hotfix/**', 'topic/**'] + pull_request: + branches: [ main, develop, 'support/**', 'hotfix/**', 'topic/**'] + +env: + THUNDER_REF: "R4.4.3" + +jobs: + L1-tests: + permissions: + contents: read + pull-requests: write + name: Build and run unit tests + runs-on: ubuntu-22.04 + + steps: + # Set up Thunder cache + - name: Set up Thunder cache + id: cache + uses: actions/cache@v3 + with: + path: | + !build/Thunder + build/ThunderInterfaces + build/ThunderTools + install + !install/etc/WPEFramework/plugins + !install/usr/bin/rdkproxy_l1_test + !install/usr/include/gmock + !install/usr/include/gtest + !install/usr/lib/libgmockd.a + !install/usr/lib/libgmock_maind.a + !install/usr/lib/libgtestd.a + !install/usr/lib/libgtest_maind.a + !install/usr/lib/cmake/GTest + !install/usr/lib/pkgconfig/gmock.pc + !install/usr/lib/pkgconfig/gmock_main.pc + !install/usr/lib/pkgconfig/gtest.pc + !install/usr/lib/pkgconfig/gtest_main.pc + !install/usr/lib/wpeframework/plugins + key: thunder-${{ env.THUNDER_REF }}-rdk + - name: Install packages + run: | + sudo apt update + sudo apt-get install -y pkg-config libglib2.0-dev libnm-dev libcurl4-openssl-dev lcov ninja-build libgupnp-1.2-1 libgupnp-1.2-dev libgssdp-1.2-0 libsoup2.4-1 + + - name: Configure Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' + - run: pip install jsonref + + - name: Configure CMake + uses: jwlawson/actions-setup-cmake@v1.13 + with: + cmake-version: '3.16.x' + - name: Checkout thunder repositories + if: steps.cache.outputs.cache-hit != 'true' + run: | + git clone https://github.com/rdkcentral/ThunderTools ThunderTools --branch ${{ env.THUNDER_REF }} + git clone https://github.com/rdkcentral/Thunder Thunder --branch ${{ env.THUNDER_REF }} + git clone https://github.com/rdkcentral/ThunderInterfaces ThunderInterfaces --branch ${{ env.THUNDER_REF }} + + - name: Checkout networkmanager + uses: actions/checkout@v3 + with: + path: networkmanager + + - name: Apply Thunder Patches + if: steps.cache.outputs.cache-hit != 'true' + run: | + cd ${{github.workspace}}/Thunder + git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/SubscribeStub.patch + + - name: Build ThunderTools + if: steps.cache.outputs.cache-hit != 'true' + run: > + cmake + -S "${{github.workspace}}/ThunderTools" -B build/ThunderTools + -DCMAKE_INSTALL_PREFIX="${{github.workspace}}/install/usr" + -DCMAKE_MODULE_PATH="${{github.workspace}}/install/tools/cmake" + -DGENERIC_CMAKE_MODULE_PATH="${{github.workspace}}/install/tools/cmake" + && + cmake --build build/ThunderTools --target install -j8 + + - name: Build Thunder + if: steps.cache.outputs.cache-hit != 'true' + run: > + cmake + -S "${{github.workspace}}/Thunder" -B build/Thunder + -DCMAKE_INSTALL_PREFIX="${{github.workspace}}/install/usr" + -DCMAKE_MODULE_PATH="${{github.workspace}}/install/tools/cmake" + -DBUILD_TYPE=Debug + -DBINDING=127.0.0.1 + -DPORT=9998 + && + cmake --build build/Thunder --target install -j8 + + - name: ThunderInterfaces + if: steps.cache.outputs.cache-hit != 'true' + run: > + cmake + -S "${{github.workspace}}/ThunderInterfaces" -B build/ThunderInterfaces + -DCMAKE_INSTALL_PREFIX="${{github.workspace}}/install/usr" + -DCMAKE_MODULE_PATH="${{github.workspace}}/install/tools/cmake" + && + cmake --build build/ThunderInterfaces --target install -j8 + + - name: Generate IARM headers + run: | + touch install/usr/lib/libIARMBus.so + mkdir -p install/usr/include/rdk/iarmbus + touch install/usr/include/rdk/iarmbus/libIARM.h + cd "${{github.workspace}}/networkmanager/tests/" + mkdir -p headers/rdk/iarmbus + cd headers + touch rdk/iarmbus/libIARM.h rdk/iarmbus/libIBus.h + + - name: Build networkmanager with RDK Proxy + run: > + cmake + -S "${{github.workspace}}/networkmanager" + -B build/networkmanager_rdk + -DCMAKE_TOOLCHAIN_FILE="${{ env.TOOLCHAIN_FILE }}" + -DCMAKE_INSTALL_PREFIX="${{github.workspace}}/install/usr" + -DCMAKE_MODULE_PATH="${{github.workspace}}/install/tools/cmake" + -DCMAKE_CXX_FLAGS=" + -I ${{github.workspace}}/networkmanager/tests/headers + -I ${{github.workspace}}/networkmanager/tests/headers/rdk/iarmbus + --include ${{github.workspace}}/networkmanager/tests/mocks/Iarm.h + --include ${{github.workspace}}/networkmanager/tests/mocks/secure_wrappermock.h + -Wall --coverage + " + -DENABLE_UNIT_TESTING=ON + -DENABLE_ROUTER_DISCOVERY_TOOL=ON + && + cmake --build build/networkmanager_rdk --target install -j8 + + - name: Run unit tests for Legacy_Network + run: > + PATH=${{github.workspace}}/install/usr/bin:${PATH} + LD_LIBRARY_PATH=${{github.workspace}}/install/usr/lib:${{github.workspace}}/install/usr/lib/wpeframework/plugins:${LD_LIBRARY_PATH} + legacynetwork_tests + + - name: Run unit tests for Legacy_WiFi + run: > + PATH=${{github.workspace}}/install/usr/bin:${PATH} + LD_LIBRARY_PATH=${{github.workspace}}/install/usr/lib:${{github.workspace}}/install/usr/lib/wpeframework/plugins:${LD_LIBRARY_PATH} + legacywifi_tests + + - name: Generate coverage + run: | + lcov -c -o coverage.info -d build/networkmanager_rdk + lcov -r coverage.info '/usr/include/*' '*/build/networkmanager_rdk/*' \ + '*/install/usr/include/*' '*/tests/*' 'googlemock/*' 'googletest/*' \ + -o filtered_coverage.info + - name: Generate the html report + run: | + genhtml filtered_coverage.info --output-directory /tmp/coverage_report + + - name: Upload the coverage report to Pull request using actions + uses: actions/upload-artifact@v4 + with: + name: coverage-report + path: | + /tmp/coverage_report + /tmp/gtest_log diff --git a/.github/workflows/libnm_proxy_L1_test.yml b/.github/workflows/libnm_proxy_L1_test.yml index ba22e3cc..d92b5f58 100644 --- a/.github/workflows/libnm_proxy_L1_test.yml +++ b/.github/workflows/libnm_proxy_L1_test.yml @@ -71,7 +71,7 @@ jobs: if: steps.cache.outputs.cache-hit != 'true' run: | cd ${{github.workspace}}/Thunder - git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/Remove-SmartLinkType.patch + git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/SubscribeStub.patch - name: Build ThunderTools if: steps.cache.outputs.cache-hit != 'true' diff --git a/.github/workflows/rdk_proxy_L1_L2_test.yml b/.github/workflows/rdk_proxy_L1_L2_test.yml index 26d97e8c..9124e4b6 100644 --- a/.github/workflows/rdk_proxy_L1_L2_test.yml +++ b/.github/workflows/rdk_proxy_L1_L2_test.yml @@ -71,7 +71,7 @@ jobs: if: steps.cache.outputs.cache-hit != 'true' run: | cd ${{github.workspace}}/Thunder - git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/Remove-SmartLinkType.patch + git apply ${{github.workspace}}/networkmanager/tests/patches/thunder/SubscribeStub.patch - name: Build ThunderTools if: steps.cache.outputs.cache-hit != 'true' diff --git a/legacy/LegacyWiFiManagerAPIs.cpp b/legacy/LegacyWiFiManagerAPIs.cpp index 463707e3..dc032dc8 100644 --- a/legacy/LegacyWiFiManagerAPIs.cpp +++ b/legacy/LegacyWiFiManagerAPIs.cpp @@ -496,7 +496,7 @@ namespace WPEFramework uint32_t WiFiManager::getSupportedSecurityModes(const JsonObject& parameters, JsonObject& response) { LOG_INPARAM(); - uint32_t rc = Core::ERROR_GENERAL; + uint32_t rc = Core::ERROR_NONE; JsonObject security_modes; security_modes["NET_WIFI_SECURITY_NONE"] = (int)NET_WIFI_SECURITY_NONE; security_modes["NET_WIFI_SECURITY_WEP_64"] = (int)NET_WIFI_SECURITY_WEP_64; diff --git a/tests/l2Test/CMakeLists.txt b/tests/l2Test/CMakeLists.txt index 9ded43a5..84bf8b97 100644 --- a/tests/l2Test/CMakeLists.txt +++ b/tests/l2Test/CMakeLists.txt @@ -19,6 +19,8 @@ message ("building l2 test") set(NM_RDK_PROXY_L2_TEST "rdkproxy_l2_test") +set(NM_LEGACY_WIFI_UT "legacywifi_tests") +set(NM_LEGACY_NETWORK_UT "legacynetwork_tests") find_package(CURL) find_package(PkgConfig REQUIRED) @@ -50,16 +52,42 @@ add_executable(${NM_RDK_PROXY_L2_TEST} ${PROXY_STUB_SOURCES} ) +add_executable(${NM_LEGACY_WIFI_UT} + ${CMAKE_SOURCE_DIR}/tests/l2Test/l2_test_LegacyPlugin_WiFiManagerAPIs.cpp + ${CMAKE_SOURCE_DIR}/tests/mocks/thunder/Module.cpp + ${CMAKE_SOURCE_DIR}/plugin/NetworkManagerLogger.cpp + ${CMAKE_SOURCE_DIR}/legacy/LegacyWiFiManagerAPIs.cpp +) + +add_executable(${NM_LEGACY_NETWORK_UT} + ${CMAKE_SOURCE_DIR}/tests/l2Test/l2_test_LegacyPlugin_NetworkAPIs.cpp + ${CMAKE_SOURCE_DIR}/tests/mocks/thunder/Module.cpp + ${CMAKE_SOURCE_DIR}/plugin/NetworkManagerLogger.cpp + ${CMAKE_SOURCE_DIR}/legacy/LegacyNetworkAPIs.cpp +) + set_target_properties(${NM_RDK_PROXY_L2_TEST} PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED YES ) +set_target_properties(${NM_LEGACY_WIFI_UT} PROPERTIES + CXX_STANDARD 11 + CXX_STANDARD_REQUIRED YES +) +set_target_properties(${NM_LEGACY_NETWORK_UT} PROPERTIES + CXX_STANDARD 11 + CXX_STANDARD_REQUIRED YES +) + target_compile_options(${NM_RDK_PROXY_L2_TEST} PRIVATE -Wall -include ${CMAKE_SOURCE_DIR}/interface/INetworkManager.h) +target_compile_options(${NM_LEGACY_WIFI_UT} PRIVATE -Wall -include ${CMAKE_SOURCE_DIR}/interface/INetworkManager.h) +target_compile_options(${NM_LEGACY_NETWORK_UT} PRIVATE -Wall -include ${CMAKE_SOURCE_DIR}/interface/INetworkManager.h) include_directories(${PROJECT_SOURCE_DIR}/interface) include_directories(${PROJECT_SOURCE_DIR}/plugin/rdk) include_directories(${PROJECT_SOURCE_DIR}/plugin) +include_directories(${PROJECT_SOURCE_DIR}/legacy) include_directories(${PROJECT_SOURCE_DIR}/tests/mocks) include_directories(${PROJECT_SOURCE_DIR}/tests/mocks/thunder) include_directories(${PROJECT_SOURCE_DIR}/../install/usr/include/rdk/iarmbus/) @@ -67,7 +95,19 @@ include_directories(${PROJECT_SOURCE_DIR}/tools/upnp/) target_include_directories(${NM_RDK_PROXY_L2_TEST} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} - ${gtest_SOURCE_DIR}/include + ${gtest_SOURCE_DIR}/include + ${gtest_SOURCE_DIR}/../googlemock/include +) + +target_include_directories(${NM_LEGACY_WIFI_UT} PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} + ${gtest_SOURCE_DIR}/include + ${gtest_SOURCE_DIR}/../googlemock/include +) + +target_include_directories(${NM_LEGACY_NETWORK_UT} PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} + ${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}/../googlemock/include ) @@ -81,5 +121,21 @@ target_link_libraries(${NM_RDK_PROXY_L2_TEST} PRIVATE ${NAMESPACE}Plugins::${NAMESPACE}Plugins ${CURL_LIBRARIES} ) +target_link_libraries(${NM_LEGACY_WIFI_UT} PRIVATE + gmock_main + ${NAMESPACE}Core::${NAMESPACE}Core + ${NAMESPACE}Plugins::${NAMESPACE}Plugins + ${NAMESPACE}Core::${NAMESPACE}Core + ${CURL_LIBRARIES} +) +target_link_libraries(${NM_LEGACY_NETWORK_UT} PRIVATE + gmock_main + ${NAMESPACE}Core::${NAMESPACE}Core + ${NAMESPACE}Plugins::${NAMESPACE}Plugins + ${NAMESPACE}Core::${NAMESPACE}Core + ${CURL_LIBRARIES} +) install(TARGETS ${NM_RDK_PROXY_L2_TEST} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) +install(TARGETS ${NM_LEGACY_WIFI_UT} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) +install(TARGETS ${NM_LEGACY_NETWORK_UT} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) diff --git a/tests/l2Test/l2_test_LegacyPlugin_NetworkAPIs.cpp b/tests/l2Test/l2_test_LegacyPlugin_NetworkAPIs.cpp new file mode 100644 index 00000000..16231583 --- /dev/null +++ b/tests/l2Test/l2_test_LegacyPlugin_NetworkAPIs.cpp @@ -0,0 +1,941 @@ +/** +* If not stated otherwise in this file or this component's LICENSE +* file the following copyright and licenses apply: +* +* Copyright 2024 RDK Management +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +**/ + +#include +#include +#include +#include +#include "ServiceMock.h" +#include "FactoriesImplementation.h" +#include "NetworkManagerLogger.h" +#include "LegacyNetworkAPIs.h" +#include "ThunderPortability.h" +#include "INetworkManager.h" +#include "INetworkManagerMock.h" +#include "LegacyNetworkMock.h" +#include "IStringIteratorMock.h" +#include "mockauthservices.h" +#include "InterfaceIteratorMock.h" + +using namespace std; +using namespace WPEFramework; +using namespace WPEFramework::Plugin; +using IStringIterator = RPC::IIteratorType; +using ::testing::NiceMock; + +class NetworkTest : public ::testing::Test{ +protected: + Core::ProxyType plugin; + Core::JSONRPC::Handler& handler; + Core::JSONRPC::Handler& handlerV2; + DECL_CORE_JSONRPC_CONX connection; + Core::JSONRPC::Message message; + string response; + ServiceMock *m_service; + bool m_subsIfaceStateChange; + bool m_subsActIfaceChange; + bool m_subsIPAddrChange; + bool m_subsInternetChange; + + NetworkTest() + : plugin(Core::ProxyType::Create()) + , handler(*(plugin)) + , handlerV2(*(plugin->GetHandler(2))) + , INIT_CONX(1, 0) + , m_subsIfaceStateChange(true) + , m_subsActIfaceChange(true) + , m_subsIPAddrChange(true) + , m_subsInternetChange(true) + { + ServiceMock* service = new ServiceMock(); + WPEFramework::PluginHost::IAuthenticate* mock_security_agent = new MockIAuthenticate(); + ServiceMock* mockShell = new ServiceMock(); + + EXPECT_CALL(*service, AddRef()).Times(1); + EXPECT_CALL(*service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(2) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("SecurityAgent"))); + return static_cast(mock_security_agent); + })) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + m_subsIfaceStateChange = true; + m_subsActIfaceChange = true; + m_subsIPAddrChange = true; + m_subsInternetChange = true; + return static_cast(mockShell); + })); + m_service = service; + EXPECT_CALL(*mockShell, State()) + .WillOnce(::testing::Return(PluginHost::IShell::state::UNAVAILABLE)) + .WillOnce(::testing::Return(PluginHost::IShell::state::UNAVAILABLE)) + .WillRepeatedly(::testing::Return(PluginHost::IShell::state::ACTIVATED)); + EXPECT_EQ(string{}, plugin->Initialize(service)); + delete mockShell; + delete mock_security_agent; + } + virtual ~NetworkTest() override + { + plugin->Deinitialize(m_service); + m_service->Release(); + delete m_service; + } +}; + +TEST_F(NetworkTest, getInterfaces) +{ + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + NiceMock mockIterator; + Exchange::INetworkManager::InterfaceDetails entry1; + entry1.type = Exchange::INetworkManager::InterfaceType::INTERFACE_TYPE_ETHERNET; + entry1.mac = "00:11:22:33:44:55"; + entry1.enabled = true; + entry1.connected = false; + + Exchange::INetworkManager::InterfaceDetails entry2; + entry2.type = Exchange::INetworkManager::InterfaceType::INTERFACE_TYPE_WIFI; + entry2.mac = "66:77:88:99:AA:BB"; + entry2.enabled = false; + entry2.connected = true; + + // Set up Next() to return two entries, then false + EXPECT_CALL(mockIterator, Next(testing::_)) + .WillOnce(testing::DoAll(testing::SetArgReferee<0>(entry1), testing::Return(true))) + .WillOnce(testing::DoAll(testing::SetArgReferee<0>(entry2), testing::Return(true))) + .WillOnce(testing::Return(false)); + EXPECT_CALL(mockIterator, Release()).Times(1); + NiceMock service; + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, GetAvailableInterfaces(::testing::_)) + .WillOnce(testing::DoAll( + ::testing::Invoke([&mockIterator](WPEFramework::Exchange::INetworkManager::IInterfaceDetailsIterator*& iterator) -> uint32_t { + iterator = &mockIterator; + return 0; + }))); + EXPECT_CALL(*mockNetworkManager, Release()).Times(1); + JsonObject parameters, JsonResponse; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getInterfaces"), _T("{}"), response)); + std::string expectedResponse = "{\"interfaces\":[{\"interface\":\"ETHERNET\",\"macAddress\":\"00:11:22:33:44:55\",\"enabled\":true,\"connected\":false},{\"interface\":\"WIFI\",\"macAddress\":\"66:77:88:99:AA:BB\",\"enabled\":false,\"connected\":true}],\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + delete mockNetworkManager; +} + +TEST_F(NetworkTest, RegisteredMethods) +{ + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getStbIp"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getInterfaces"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("setStunEndPoint"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("isInterfaceEnabled"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("setInterfaceEnabled"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getDefaultInterface"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getIPSettings"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("isConnectedToInternet"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getPublicIP"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getSTBIPFamily"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("setConnectivityTestEndpoints"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getCaptivePortalURI"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("startConnectivityMonitoring"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("stopConnectivityMonitoring"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("setDefaultInterface"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("setIPSettings"))); + EXPECT_EQ(Core::ERROR_NONE, handlerV2.Exists(_T("getIPSettings"))); +} + +TEST_F(NetworkTest, setStunEndpoint) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + string endpoint = "stun.example.com"; + uint32_t port = 3478; + uint32_t bindTimeout = 10; + uint32_t cacheTimeout = 30; + + JsonObject parameters; + parameters["server"] = endpoint; + parameters["port"] = port; + parameters["timeout"] = bindTimeout; + parameters["cache_timeout"] = cacheTimeout; + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, SetStunEndpoint(::testing::_, ::testing::_, ::testing::_, ::testing::_)) + .WillOnce(::testing::Invoke([&](string const endpoint, const uint32_t port, const uint32_t timeout, const uint32_t cacheLifetime ) -> uint32_t { + return 0; + })); + EXPECT_CALL(*mockNetworkManager, Release()).Times(1); + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setStunEndPoint"), _T("{}"), response)); + EXPECT_EQ(response, "{\"success\":true}"); + delete mockNetworkManager; +} + +TEST_F(NetworkTest, setInterfaceEnabled){ + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + string interface = "ETHERNET"; + bool enabled = true; + + JsonObject jsonParameters; + jsonParameters["interface"] = interface; + jsonParameters["enabled"] = enabled; + string parameters; + jsonParameters.ToString(parameters); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, SetInterfaceState(::testing::_, ::testing::_)) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setInterfaceEnabled"), _T(parameters), response)); + EXPECT_EQ(response, "{\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getDefaultInterface) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + string interface = "eth0"; + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, GetPrimaryInterface(::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& interface) -> uint32_t { + interface = "eth0"; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getDefaultInterface"), _T("{}"), response)); + EXPECT_EQ(response, "{\"interface\":\"ETHERNET\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, setDefaultInterface) { + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setDefaultInterface"), _T("{}"), response)); + EXPECT_EQ(response, "{\"success\":true}"); +} + +TEST_F(NetworkTest, setIPSettings) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv4"; + jsonParameters["autoconfig"] = false; + jsonParameters["ipaddr"] = "192.168.1.100"; + jsonParameters["gateway"] = "192.168.1.1"; + jsonParameters["primarydns"] = "8.8.8.8"; + jsonParameters["secondarydns"] = "8.8.4.4"; + jsonParameters["netmask"] = "255.255.255.0"; + + string parameters; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, SetIPSettings(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setIPSettings"), _T(parameters), response)); + EXPECT_EQ(response, "{\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getIPSettings) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + WPEFramework::Exchange::INetworkManager::IPAddress address{}; + EXPECT_CALL(*mockNetworkManager, GetIPSettings(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , const string&, WPEFramework::Exchange::INetworkManager::IPAddress& address) -> uint32_t { + address.primarydns = "75.75.75.76"; + address.secondarydns = "75.75.76.76"; + address.dhcpserver = "192.168.0.1"; + address.gateway = "192.168.0.1"; + address.ipaddress = "192.168.0.11"; + address.ipversion = "IPv4"; + address.prefix = 24; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getIPSettings"), _T(parameters), response)); + EXPECT_EQ(response, "{\"primarydns\":\"75.75.75.76\",\"gateway\":\"192.168.0.1\",\"secondarydns\":\"75.75.76.76\",\"dhcpserver\":\"192.168.0.1\",\"netmask\":\"255.255.255.0\",\"ipaddr\":\"192.168.0.11\",\"autoconfig\":false,\"ipversion\":\"IPv4\",\"interface\":\"WIFI\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getIPSettingsIPv6) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv6"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + WPEFramework::Exchange::INetworkManager::IPAddress address{}; + EXPECT_CALL(*mockNetworkManager, GetIPSettings(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , const string&, WPEFramework::Exchange::INetworkManager::IPAddress& address) -> uint32_t { + address.ipaddress = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"; + address.ipversion = "IPv6"; + address.prefix = 64; + address.primarydns = "2001:4860:4860::8888"; + address.gateway = "fe80::1"; + address.secondarydns = "2001:4860:4860::8844"; + address.dhcpserver = "fe80::2"; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getIPSettings"), _T(parameters), response)); + EXPECT_EQ(response, "{\"primarydns\":\"2001:4860:4860::8888\",\"gateway\":\"fe80::1\",\"secondarydns\":\"2001:4860:4860::8844\",\"dhcpserver\":\"fe80::2\",\"netmask\":64,\"ipaddr\":\"2001:0db8:85a3:0000:0000:8a2e:0370:7334\",\"autoconfig\":false,\"ipversion\":\"IPv6\",\"interface\":\"WIFI\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getIPSettingsErrorEmptyString) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + WPEFramework::Exchange::INetworkManager::IPAddress address{}; + EXPECT_CALL(*mockNetworkManager, GetIPSettings(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , const string&, WPEFramework::Exchange::INetworkManager::IPAddress& address) -> uint32_t { + address.ipaddress = ""; + address.ipversion = "IPv4"; + address.prefix = 34; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getIPSettings"), _T(parameters), response)); + EXPECT_EQ(response, "{\"success\":false}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getIPSettings2) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + WPEFramework::Exchange::INetworkManager::IPAddress address{}; + EXPECT_CALL(*mockNetworkManager, GetIPSettings(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , const string&, WPEFramework::Exchange::INetworkManager::IPAddress& address) -> uint32_t { + address.primarydns = "75.75.75.76"; + address.secondarydns = "75.75.76.76"; + address.dhcpserver = "192.168.0.1"; + address.gateway = "192.168.0.1"; + address.ipaddress = "192.168.0.11"; + address.ipversion = "IPv4"; + address.prefix = 24; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handlerV2.Invoke(connection, _T("getIPSettings"), _T(parameters), response)); + string expectedResponse = "{\"interface\":\"WIFI\",\"ipversion\":\"IPv4\",\"autoconfig\":false,\"ipaddr\":\"192.168.0.11\",\"netmask\":\"255.255.255.0\",\"dhcpserver\":\"192.168.0.1\",\"gateway\":\"192.168.0.1\",\"primarydns\":\"75.75.75.76\",\"secondarydns\":\"75.75.76.76\",\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, isConnectedToInternet) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, IsConnectedToInternet(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , string&, WPEFramework::Exchange::INetworkManager::InternetStatus& result) -> uint32_t + { + result = WPEFramework::Exchange::INetworkManager::InternetStatus::INTERNET_FULLY_CONNECTED; + return Core::ERROR_NONE; + })); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("isConnectedToInternet"), _T(parameters), response)); + EXPECT_EQ(response, "{\"ipversion\":\"IPv4\",\"connectedToInternet\":true,\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getInternetConnectionState) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, IsConnectedToInternet(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const string&, const string&, Exchange::INetworkManager::InternetStatus& status) { + status = Exchange::INetworkManager::InternetStatus::INTERNET_CAPTIVE_PORTAL; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, GetCaptivePortalURI(::testing::_)) + .Times(1) + .WillOnce(::testing::DoAll( + ::testing::SaveArg<0>(&response), + ::testing::Return(Core::ERROR_NONE))); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getInternetConnectionState"), _T(parameters), response)); + EXPECT_EQ(response, "{\"ipversion\":\"IPv4\",\"state\":2,\"URI\":\"\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, doPing) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + std::string traceResult = "{" + "\"success\": true," + "\"tripStdDev\": \"0.741 ms\"," + "\"tripAvg\": \"16.702\"," + "\"tripMin\": \"15.747\"," + "\"tripMax\": \"17.564\"," + "\"packetLoss\": \"0\"," + "\"endpoint\": \"8.8.8.8\"," + "\"packetsReceived\": 5," + "\"packetsTransmitted\": 5," + "\"target\": \"8.8.8.8\"" + "}"; + EXPECT_CALL(*mockNetworkManager, Ping(::testing::_, ::testing::_, ::testing::_, ::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const string, const string, const uint32_t, const uint16_t, const string, string& result) -> uint32_t + { + result = traceResult; + return Core::ERROR_NONE; + })); + + JsonObject parametersJson; + parametersJson["endpoint"] = "8.8.8.8"; + parametersJson["packets"] = 5; + parametersJson["ipversion"] = "IPv4"; + parametersJson["guid"] = "..."; + string parameters; + parametersJson.ToString(parameters); + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("ping"), _T(parameters), response)); + string expectedResponse = "{\"packetsTransmitted\":5,\"packetsReceived\":5,\"packetLoss\":\"0\",\"target\":\"8.8.8.8\",\"tripMax\":\"17.564\",\"tripMin\":\"15.747\",\"tripAvg\":\"16.702\",\"tripStdDev\":\"0.741 ms\",\"endpoint\":\"8.8.8.8\",\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, doTrace) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + std::string traceResult = "{" + "\"results\": \"[\\\"traceroute to 8.8.8.8 (8.8.8.8), 6 hops max, 52 byte packets \\\",\\\"" + "1 gateway (10.46.5.1) 0.448 ms\\\",\\\"" + "2 10.46.0.240 (10.46.0.240) 3.117 ms\\\",\\\"" + "3 *\\\",\\\"" + "4 *\\\",\\\"" + "5 *\\\",\\\"" + "6 *\\\"]\"," + "\"endpoint\": \"8.8.8.8\"," + "\"success\": true" + "}"; + EXPECT_CALL(*mockNetworkManager, Trace(::testing::_, ::testing::_, ::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const string, const string, const uint32_t, const string, string& response1) -> uint32_t + { + response1 = traceResult; + return Core::ERROR_NONE; + })); + + JsonObject parametersJson; + parametersJson["endpoint"] = "8.8.8.8"; + parametersJson["ipversion"] = "IPv4"; + parametersJson["packets"] = 1; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("trace"), _T(parametersStr), response)); + // We expect the response to contain success and results fields + EXPECT_TRUE(response.find("\"success\":true") != std::string::npos); + EXPECT_TRUE(response.find("\"results\":") != std::string::npos); + EXPECT_TRUE(response.find("\"endpoint\":\"8.8.8.8\"") != std::string::npos); + EXPECT_TRUE(response.find("\"target\":\"8.8.8.8\"") != std::string::npos); + EXPECT_TRUE(response.find("6 hops max, 52 byte packets") != std::string::npos); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getPublicIP) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, GetPublicIP(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string&, string&, string& ipaddress) { + ipaddress = "69.136.49.95"; + return Core::ERROR_NONE; + })); + + + JsonObject parametersJson; + parametersJson["ipv6"] = true; + parametersJson["iface"] = "WIFI"; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getPublicIP"), _T(parametersStr), response)); + EXPECT_EQ(response, "{\"public_ip\":\"69.136.49.95\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, isInterfaceEnabled) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, GetInterfaceState(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::DoAll( + ::testing::Return(Core::ERROR_NONE))); + + JsonObject parametersJson; + parametersJson["interface"] = "WIFI"; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("isInterfaceEnabled"), _T(parametersStr), response)); + EXPECT_EQ(response, "{\"enabled\":false,\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, isInterfaceEnabledErrorInvalidInterface) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + JsonObject parametersJson; + parametersJson["interface"] = "INVALID"; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_BAD_REQUEST, handler.Invoke(connection, _T("isInterfaceEnabled"), _T(parametersStr), response)); + EXPECT_EQ(response, string{}); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, setConnectivityTestEndpoints) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, SetConnectivityTestEndpoints(::testing::_)) + .Times(1) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + + JsonArray array; + array.Add("http://example.com"); + array.Add("http://example2.com"); + array.Add("http://example3.com"); + + JsonObject parametersJson; + parametersJson["endpoints"] = array; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setConnectivityTestEndpoints"), _T(parametersStr), response)); + EXPECT_EQ(response, "{\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, setConnectivityTestEndpointsErrorInvalidType) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + JsonArray array; + array.Add("http://example.com"); + array.Add(1234); + array.Add("http://example3.com"); + + JsonObject parametersJson; + parametersJson["endpoints"] = array; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setConnectivityTestEndpoints"), _T(parametersStr), response)); + EXPECT_EQ(response, "{\"success\":false}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, setConnectivityTestEndpointsErrorEmptyArray) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + JsonArray array; + + JsonObject parametersJson; + string parametersStr; + parametersJson.ToString(parametersStr); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setConnectivityTestEndpoints"), _T(parametersStr), response)); + EXPECT_EQ(response, "{\"success\":false}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, startConnectivityMonitoring) { + string parameters; + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("startConnectivityMonitoring"), _T(parameters), response)); + EXPECT_EQ(response, "{\"success\":true}"); +} + +TEST_F(NetworkTest, getCaptivePortalURI) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + string parameters; + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + EXPECT_CALL(*mockNetworkManager, GetCaptivePortalURI(::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& uri) { + uri = "http://10.0.0.1/captiveportal.jst"; + return Core::ERROR_NONE; + })); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getCaptivePortalURI"), _T(parameters), response)); + EXPECT_EQ(response, "{\"uri\":\"http:\\/\\/10.0.0.1\\/captiveportal.jst\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, stopConnectivityMonitoring) { + string parameters; + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("stopConnectivityMonitoring"), _T(parameters), response)); + EXPECT_EQ(response, "{\"success\":true}"); +} + +TEST_F(NetworkTest, getStbIp) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, GetIPSettings(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , const string&, WPEFramework::Exchange::INetworkManager::IPAddress& address) -> uint32_t { + address.ipaddress = "192.168.0.1"; + address.ipversion = "IPv4"; + address.prefix = 24; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getStbIp"), _T(parameters), response)); + EXPECT_EQ(response, "{\"ip\":\"192.168.0.1\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, getSTBIPFamily) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + JsonObject jsonParameters; + jsonParameters["interface"] = "WIFI"; + jsonParameters["ipversion"] = "IPv4"; + string parameters; + string response; + jsonParameters.ToString(parameters); + + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, GetIPSettings(::testing::_, ::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](string& , const string&, WPEFramework::Exchange::INetworkManager::IPAddress& address) -> uint32_t { + address.ipaddress = "192.168.0.1"; + address.ipversion = "IPv4"; + address.prefix = 24; + return Core::ERROR_NONE; + })); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getSTBIPFamily"), _T({}), response)); + EXPECT_EQ(response, "{\"ip\":\"192.168.0.1\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(NetworkTest, ReportonInterfaceStateChangeAdded) { + StubNetwork network; + JsonObject parameters; + parameters["status"] = "INTERFACE_ADDED"; + parameters["interface"] = "ETHERNET"; + network.onInterfaceStateChange(parameters); +} + +TEST_F(NetworkTest, ReportonInterfaceStateChangeRemoved) { + StubNetwork network; + JsonObject parameters; + parameters["status"] = "INTERFACE_REMOVED"; + parameters["interface"] = "eth0"; + network.onInterfaceStateChange(parameters); +} + +TEST_F(NetworkTest, ReportonInterfaceStateChangeLinkUp) { + StubNetwork network; + JsonObject parameters; + parameters["status"] = "INTERFACE_LINK_UP"; + parameters["interface"] = "wlan0"; + network.onInterfaceStateChange(parameters); +} + +TEST_F(NetworkTest, ReportonInterfaceStateChangeLinkDown) { + StubNetwork network; + JsonObject parameters; + parameters["status"] = "INTERFACE_LINK_DOWN"; + parameters["interface"] = "eth0"; + network.onInterfaceStateChange(parameters); +} + +TEST_F(NetworkTest, ReportonActiveInterfaceChange) { + StubNetwork network; + JsonObject parameters; + parameters["prevActiveInterface"] = "eth0"; + parameters["currentActiveInterface"] = "wlan0"; + network.onActiveInterfaceChange(parameters); +} + +TEST_F(NetworkTest, ReportonIPAddressChange_IPv4) { + StubNetwork network; + JsonObject parameters; + parameters["interface"] = "eth0"; + parameters["ipversion"] = "IPv4"; + parameters["ipaddress"] = "192.168.1.100"; + network.onIPAddressChange(parameters); +} + +TEST_F(NetworkTest, ReportonIPAddressChange_IPv6) { + StubNetwork network; + JsonObject parameters; + parameters["interface"] = "wlan0"; + parameters["ipversion"] = "IPv6"; + parameters["ipaddress"] = "fe80::1"; + + network.onIPAddressChange(parameters); +} + +TEST_F(NetworkTest, ReportonInternetStatusChange) { + StubNetwork network; + JsonObject parameters; + parameters["state"] = "CONNECTED"; + parameters["status"] = "OK"; + network.onInternetStatusChange(parameters); +} + +TEST_F(NetworkTest, Information) { + StubNetwork network; + network.Information(); +} diff --git a/tests/l2Test/l2_test_LegacyPlugin_WiFiManagerAPIs.cpp b/tests/l2Test/l2_test_LegacyPlugin_WiFiManagerAPIs.cpp new file mode 100644 index 00000000..aa2c8a56 --- /dev/null +++ b/tests/l2Test/l2_test_LegacyPlugin_WiFiManagerAPIs.cpp @@ -0,0 +1,898 @@ +/** +* If not stated otherwise in this file or this component's LICENSE +* file the following copyright and licenses apply: +* +* Copyright 2024 RDK Management +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +**/ + +#include +#include +#include +#include "ServiceMock.h" +#include "FactoriesImplementation.h" +#include "NetworkManagerLogger.h" +#include "LegacyWiFiManagerAPIs.h" +#include "ThunderPortability.h" +#include "INetworkManagerMock.h" +#include "LegacyWiFiManagerMock.h" +#include "IStringIteratorMock.h" +#include "mockauthservices.h" + +using namespace std; +using namespace WPEFramework; +using namespace WPEFramework::Plugin; +using ::testing::NiceMock; + +#define WPA_SUPPLICANT_CONF "/opt/secure/wifi/wpa_supplicant.conf/wpa_supplicant.conf" + +Plugin::WiFiManager* _gWiFiInstance = nullptr; +class WiFiManagerTest : public ::testing::Test { +protected: + Core::ProxyType plugin; + Core::JSONRPC::Handler& handler; + Core::JSONRPC::Handler& handlerV2; + DECL_CORE_JSONRPC_CONX connection; + ServiceMock *m_service; + Core::JSONRPC::Message message; + string response; + + WiFiManagerTest() + : plugin(Core::ProxyType::Create()) + , handler(*(plugin)) + , handlerV2(*(plugin->GetHandler(2))) + , INIT_CONX(1, 0) + { + ServiceMock* service = new ServiceMock(); + WPEFramework::PluginHost::IAuthenticate* mock_security_agent = new MockIAuthenticate(); + ServiceMock* mockShell = new ServiceMock(); + + EXPECT_CALL(*service, AddRef()).Times(1); + EXPECT_CALL(*service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(2) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("SecurityAgent"))); + return static_cast(mock_security_agent); + })) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockShell); + })); + m_service = service; + EXPECT_CALL(*mockShell, State()) + .WillOnce(::testing::Return(PluginHost::IShell::state::UNAVAILABLE)) + .WillOnce(::testing::Return(PluginHost::IShell::state::UNAVAILABLE)) + .WillRepeatedly(::testing::Return(PluginHost::IShell::state::ACTIVATED)); + EXPECT_EQ(string{}, plugin->Initialize(service)); + delete mockShell; + delete mock_security_agent; + } + + virtual ~WiFiManagerTest() override + { + plugin->Deinitialize(m_service); + m_service->Release(); + delete m_service; + } +}; + +TEST_F(WiFiManagerTest, TestedAPIsShouldExist) +{ + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("startScan"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("stopScan"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("connect"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("disconnect"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("initiateWPSPairing"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("cancelWPSPairing"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("saveSSID"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("clearSSID"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getPairedSSID"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getPairedSSIDInfo"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("isPaired"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getCurrentState"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("getConnectedSSID"))); + EXPECT_EQ(Core::ERROR_NONE, handler.Exists(_T("retrieveSSID"))); +} + +TEST_F(WiFiManagerTest, cancelWPSPairing) +{ + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, StopWPS()) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("cancelWPSPairing"), _T("{}"), response)); + EXPECT_EQ(response, "{\"result\":\"\",\"success\":true}"); + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, clearSSID) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, RemoveKnownSSID(::testing::_)) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("clearSSID"), _T("{}"), response)); + EXPECT_EQ(response, "{\"result\":0,\"success\":true}"); + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, connect) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, WiFiConnect(::testing::_)) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Create a sample parameters object + JsonObject jsonParameters; + jsonParameters["ssid"] = "my-ssid"; + jsonParameters["passphrase"] = "my-passphrase"; + jsonParameters["securityMode"] = 1; // Assuming 1 is the value for WPA2 + + string parameters; + jsonParameters.ToString(parameters); + // Call the connect method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("connect"), parameters, response)); + EXPECT_EQ(response, "{\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getConnectedSSID) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiSSIDInfo ssidInfo{}; + ssidInfo.ssid = "my-ssid"; + ssidInfo.bssid = "00:11:22:33:44:55"; + ssidInfo.rate = "100"; + ssidInfo.noise = "-50"; + ssidInfo.security = Exchange::INetworkManager::WIFISecurityMode::WIFI_SECURITY_WPA_PSK; + ssidInfo.strength = "50"; + ssidInfo.frequency = "2.4"; + EXPECT_CALL(*mockNetworkManager, GetConnectedSSID(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(ssidInfo), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getConnectedSSID method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getConnectedSSID"), _T("{}"), response)); + + std::string expectedResponse = "{\"ssid\":\"my-ssid\",\"bssid\":\"00:11:22:33:44:55\",\"rate\":\"100\",\"noise\":\"-50\",\"security\":6,\"signalStrength\":\"50\",\"frequency\":\"2.4\",\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getConnectedSSIDSAE) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiSSIDInfo ssidInfo{}; + ssidInfo.ssid = "my-ssid"; + ssidInfo.bssid = "00:11:22:33:44:55"; + ssidInfo.rate = "100"; + ssidInfo.noise = "-50"; + ssidInfo.security = Exchange::INetworkManager::WIFISecurityMode::WIFI_SECURITY_SAE; + ssidInfo.strength = "50"; + ssidInfo.frequency = "2.4"; + EXPECT_CALL(*mockNetworkManager, GetConnectedSSID(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(ssidInfo), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getConnectedSSID method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getConnectedSSID"), _T("{}"), response)); + + std::string expectedResponse = "{\"ssid\":\"my-ssid\",\"bssid\":\"00:11:22:33:44:55\",\"rate\":\"100\",\"noise\":\"-50\",\"security\":14,\"signalStrength\":\"50\",\"frequency\":\"2.4\",\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getConnectedSSIDEAP) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiSSIDInfo ssidInfo{}; + ssidInfo.ssid = "my-ssid"; + ssidInfo.bssid = "00:11:22:33:44:55"; + ssidInfo.rate = "100"; + ssidInfo.noise = "-50"; + ssidInfo.security = Exchange::INetworkManager::WIFISecurityMode::WIFI_SECURITY_EAP; + ssidInfo.strength = "50"; + ssidInfo.frequency = "2.4"; + EXPECT_CALL(*mockNetworkManager, GetConnectedSSID(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(ssidInfo), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getConnectedSSID method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getConnectedSSID"), _T("{}"), response)); + + std::string expectedResponse = "{\"ssid\":\"my-ssid\",\"bssid\":\"00:11:22:33:44:55\",\"rate\":\"100\",\"noise\":\"-50\",\"security\":12,\"signalStrength\":\"50\",\"frequency\":\"2.4\",\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getCurrentState) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiState state = Exchange::INetworkManager::WiFiState::WIFI_STATE_CONNECTED; + EXPECT_CALL(*mockNetworkManager, GetWifiState(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(state), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getCurrentState method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getCurrentState"), _T("{}"), response)); + + std::string expectedResponse = "{\"state\":5,\"success\":true}"; + // Verify the response + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getCurrentStateFailed1) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiState state = Exchange::INetworkManager::WiFiState::WIFI_STATE_ERROR; + EXPECT_CALL(*mockNetworkManager, GetWifiState(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(state), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getCurrentState method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getCurrentState"), _T("{}"), response)); + + std::string expectedResponse = "{\"state\":6,\"success\":true}"; + // Verify the response + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getCurrentStateFailed2) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiState state = Exchange::INetworkManager::WiFiState::WIFI_STATE_CONNECTION_INTERRUPTED; + EXPECT_CALL(*mockNetworkManager, GetWifiState(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(state), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getCurrentState method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getCurrentState"), _T("{}"), response)); + + std::string expectedResponse = "{\"state\":2,\"success\":true}"; + // Verify the response + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getCurrentStateDisconnected) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiState state = Exchange::INetworkManager::WiFiState::WIFI_STATE_DISCONNECTED; + EXPECT_CALL(*mockNetworkManager, GetWifiState(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(state), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getCurrentState method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getCurrentState"), _T("{}"), response)); + + std::string expectedResponse = "{\"state\":2,\"success\":true}"; + // Verify the response + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getCurrentStateConnected) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiState state = Exchange::INetworkManager::WiFiState::WIFI_STATE_CONNECTED; + EXPECT_CALL(*mockNetworkManager, GetWifiState(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(state), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getCurrentState method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getCurrentState"), _T("{}"), response)); + + std::string expectedResponse = "{\"state\":5,\"success\":true}"; + // Verify the response + EXPECT_EQ(response, expectedResponse); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getPairedSSIDInfo) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiSSIDInfo ssidInfo{}; + ssidInfo.ssid = "my-ssid"; + ssidInfo.bssid = "00:11:22:33:44:55"; + EXPECT_CALL(*mockNetworkManager, GetConnectedSSID(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(ssidInfo), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the getPairedSSIDInfo method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getPairedSSIDInfo"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"ssid\":\"my-ssid\",\"bssid\":\"00:11:22:33:44:55\",\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, getSupportedSecurityModes) { + // Call the getSupportedSecurityModes method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getSupportedSecurityModes"), _T("{}"), response)); + + // Verify the response + std::string expectedResponse = "{\"security_modes\":{\"NET_WIFI_SECURITY_NONE\":0,\"NET_WIFI_SECURITY_WEP_64\":1,\"NET_WIFI_SECURITY_WEP_128\":2,\"NET_WIFI_SECURITY_WPA_PSK_TKIP\":3,\"NET_WIFI_SECURITY_WPA_PSK_AES\":4,\"NET_WIFI_SECURITY_WPA2_PSK_TKIP\":5,\"NET_WIFI_SECURITY_WPA2_PSK_AES\":6,\"NET_WIFI_SECURITY_WPA_ENTERPRISE_TKIP\":7,\"NET_WIFI_SECURITY_WPA_ENTERPRISE_AES\":8,\"NET_WIFI_SECURITY_WPA2_ENTERPRISE_TKIP\":9,\"NET_WIFI_SECURITY_WPA2_ENTERPRISE_AES\":10,\"NET_WIFI_SECURITY_WPA_WPA2_PSK\":11,\"NET_WIFI_SECURITY_WPA_WPA2_ENTERPRISE\":12,\"NET_WIFI_SECURITY_WPA3_PSK_AES\":13,\"NET_WIFI_SECURITY_WPA3_SAE\":14,\"NET_WIFI_SECURITY_NOT_SUPPORTED\":99},\"success\":true}"; + EXPECT_EQ(response, expectedResponse); + +} + +TEST_F(WiFiManagerTest, saveSSID) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + Exchange::INetworkManager::WiFiConnectTo ssid{}; + ssid.ssid = "my-ssid"; + ssid.passphrase = "my-passphrase"; + ssid.security = Exchange::INetworkManager::WIFISecurityMode::WIFI_SECURITY_WPA_PSK; + EXPECT_CALL(*mockNetworkManager, AddToKnownSSIDs(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Create a sample parameters object + JsonObject jsonParameters; + jsonParameters["ssid"] = "my-ssid"; + jsonParameters["passphrase"] = "my-passphrase"; + jsonParameters["security"] = 1; // Assuming 1 is the value for WPA2 + + string parameters; + jsonParameters.ToString(parameters); + // Call the saveSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("saveSSID"), parameters, response)); + + // Verify the response + EXPECT_EQ(response, "{\"result\":0,\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, disconnect) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, WiFiDisconnect()) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the disconnect method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("disconnect"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"result\":0,\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, initiateWPSPairing) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, StartWPS(::testing::_, ::testing::_)) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Create a sample parameters object + JsonObject jsonParameters; + jsonParameters["method"] = static_cast(Exchange::INetworkManager::WiFiWPS::WIFI_WPS_PIN); + jsonParameters["pin"] = "my-pin"; + + string parameters; + jsonParameters.ToString(parameters); + // Call the initiateWPSPairing method + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("initiateWPSPairing"), parameters, response)); + + // Verify the response + EXPECT_EQ(response, "{\"result\":0,\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, startScan) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, StartWiFiScan(::testing::_, ::testing::_)) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Create a sample parameters object + JsonObject jsonParameters; + jsonParameters["frequency"] = "2.4GHz"; + jsonParameters["ssid"] = "test"; + + // Call the startScan method + std::string parameters; + jsonParameters.ToString(parameters); + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("startScan"), parameters, response)); + + // Verify the response + EXPECT_EQ(response, "{\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, stopScan) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, StopWiFiScan()) + .WillOnce(::testing::Return(Core::ERROR_NONE)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the stopScan method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("stopScan"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"success\":true}"); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, stopScan_Error) { + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + EXPECT_CALL(*mockNetworkManager, StopWiFiScan()) + .WillOnce(::testing::Return(Core::ERROR_GENERAL)); + EXPECT_CALL(*mockNetworkManager, Release()) + .Times(1); + + // Call the stopScan method + std::string response; + EXPECT_EQ(Core::ERROR_GENERAL, handler.Invoke(connection, _T("stopScan"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, string{}); + + delete mockNetworkManager; +} + +TEST_F(WiFiManagerTest, onWiFiStateChange1) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_SSID_CHANGED); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange2) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_CONNECTION_LOST); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange3) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_CONNECTION_FAILED); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange4) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_CONNECTION_INTERRUPTED); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange5) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_INVALID_CREDENTIALS); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange6) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_SSID_NOT_FOUND); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange7) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_ERROR); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiStateChange8) { + StubWiFi wifi; + JsonObject parameters; + parameters["state"] = static_cast(Exchange::INetworkManager::WIFI_STATE_AUTHENTICATION_FAILED); + wifi.onWiFiStateChange(parameters); +} + +TEST_F(WiFiManagerTest, onAvailableSSIDs) { + StubWiFi wifi; + JsonObject parameters; + JsonArray ssids; + JsonObject ssid1; + ssid1["ssid"] = "test"; + ssid1["security"] = 2; + ssid1["signalStrength"] = "-27.000"; + ssid1["frequency"] = "2.4"; + ssids.Add(ssid1); + parameters["ssids"] = ssids; + + wifi.onAvailableSSIDs(parameters); +} + +TEST_F(WiFiManagerTest, onWiFiSignalQualityChange) { + StubWiFi wifi; + JsonObject parameters; + parameters["signalStrength"] = "27.00"; + parameters["strength"] = "Excellent"; + + wifi.onWiFiSignalQualityChange(parameters); +} + +TEST_F(WiFiManagerTest, Information) { + StubWiFi wifi; + wifi.Information(); +} + +TEST_F(WiFiManagerTest, getPairedSSID) { + // Create a mock network manager object + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + // Set up the mock network manager to return a mock string iterator + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + // Set up the mock string iterator to return a string + MockStringIterator* mockStringIterator = new MockStringIterator(); + EXPECT_CALL(*mockNetworkManager, GetKnownSSIDs(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(mockStringIterator), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockStringIterator, Next(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>("my-ssid"), + ::testing::Return(true))); + + // Call the getPairedSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("getPairedSSID"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"ssid\":\"my-ssid\",\"success\":true}"); + + // Clean up + delete mockNetworkManager; + delete mockStringIterator; +} + +TEST_F(WiFiManagerTest, isPaired) { + // Create a mock network manager object + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + // Set up the mock network manager to return a mock string iterator + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + // Set up the mock string iterator to return a string + MockStringIterator* mockStringIterator = new MockStringIterator(); + EXPECT_CALL(*mockNetworkManager, GetKnownSSIDs(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>(mockStringIterator), + ::testing::Return(Core::ERROR_NONE))); + EXPECT_CALL(*mockStringIterator, Next(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::SetArgReferee<0>("my-ssid"), + ::testing::Return(true))); + + // Call the getPairedSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("isPaired"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"result\":1,\"success\":true}"); + + // Clean up + delete mockNetworkManager; + delete mockStringIterator; +} + +TEST_F(WiFiManagerTest, isPairedNoSSID) { + // Create a mock network manager object + MockINetworkManager* mockNetworkManager = new MockINetworkManager(); + + // Set up the mock network manager to return a mock string iterator + EXPECT_CALL(*m_service, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .Times(1) + .WillOnce(::testing::Invoke( + [&](const uint32_t, const string& name) -> void* { + EXPECT_EQ(name, string(_T("org.rdk.NetworkManager.1"))); + return static_cast(mockNetworkManager); + })); + + // Set up the mock string iterator to return a string + EXPECT_CALL(*mockNetworkManager, GetKnownSSIDs(::testing::_)) + .WillOnce(::testing::DoAll( + ::testing::Return(Core::ERROR_NONE))); + + // Call the getPairedSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("isPaired"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"result\":0,\"success\":true}"); + + // Clean up + delete mockNetworkManager; +} + +// Create a sample configuration file +std::string configFileContent = "ssid=\"my-ssid\"\n" +"key_mgmt=PSK\n" +"psk=\"my-passphrase\"\n"; + +void wpaSupplicantConfCreate(std::string configFileContent) +{ + std::string filePath = "/opt/secure/wifi/wpa_supplicant.conf"; + // Create the parent directories if they don't exist + size_t pos = filePath.find_last_of('/'); + if (pos != std::string::npos) { + std::string dirPath = filePath.substr(0, pos); + std::string cmd = "mkdir -p " + dirPath; + FILE* pipe = popen(cmd.c_str(), "w"); + if (!pipe) { + // Handle error + } + pclose(pipe); + } + std::ofstream configFileOut(filePath, std::ios_base::out | std::ios_base::app); + // Check if the file is open + if (configFileOut.is_open()) { + // File is open, write to it + configFileOut << configFileContent; + configFileOut.close(); + + // Print the content of the file + std::ifstream configFileRead(filePath); + if (configFileRead.is_open()) { + std::cout << configFileRead.rdbuf(); + configFileRead.close(); + } else { + std::cerr << "Unable to open file for reading." << std::endl; + } + } else { + std::cerr << "Unable to open file for writing." << std::endl; + } +} + +TEST_F(WiFiManagerTest, retrieveSSIDWPAPSK) { + std::string configFileContent = "ssid=\"my-ssid\"\n" + "key_mgmt=PSK\n" + "psk=\"my-passphrase\"\n"; + + wpaSupplicantConfCreate(configFileContent); + // Call the retrieveSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("retrieveSSID"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"ssid\":\"my-ssid\",\"securityMode\":6,\"passphrase\":\"my-passphrase\",\"success\":true}"); + + // Remove the configuration file + std::remove("/opt/secure/wifi/wpa_supplicant.conf"); +} + +TEST_F(WiFiManagerTest, retrieveSSIDSecurityNone) { + std::string configFileContent = "ssid=\"my-ssid\"\n" + "key_mgmt=NONE\n" + "psk=\"my-passphrase\"\n"; + + wpaSupplicantConfCreate(configFileContent); + // Call the retrieveSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("retrieveSSID"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"ssid\":\"my-ssid\",\"securityMode\":0,\"passphrase\":\"my-passphrase\",\"success\":true}"); + + // Remove the configuration file + std::remove("/opt/secure/wifi/wpa_supplicant.conf"); +} + +TEST_F(WiFiManagerTest, retrieveSSIDSecuritySAE) { + std::string configFileContent = "ssid=\"my-ssid\"\n" + "key_mgmt=SAE\n" + "psk=\"my-passphrase\"\n"; + + wpaSupplicantConfCreate(configFileContent); + // Call the retrieveSSID method + std::string response; + EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("retrieveSSID"), _T("{}"), response)); + + // Verify the response + EXPECT_EQ(response, "{\"ssid\":\"my-ssid\",\"securityMode\":14,\"passphrase\":\"my-passphrase\",\"success\":true}"); + + // Remove the configuration file + std::remove("/opt/secure/wifi/wpa_supplicant.conf"); +} diff --git a/tests/mocks/INetworkManagerMock.h b/tests/mocks/INetworkManagerMock.h new file mode 100644 index 00000000..7aad39b3 --- /dev/null +++ b/tests/mocks/INetworkManagerMock.h @@ -0,0 +1,60 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "Module.h" + +class MockINetworkManager : public WPEFramework::Exchange::INetworkManager { +public: + MOCK_METHOD(uint32_t, GetAvailableInterfaces, (WPEFramework::Exchange::INetworkManager::IInterfaceDetailsIterator*& interfaces), (override)); + MOCK_METHOD(uint32_t, GetPrimaryInterface, (string& interface), (override)); MOCK_METHOD(uint32_t, SetInterfaceState, (const string& interface, const bool enabled), (override)); + MOCK_METHOD(uint32_t, GetInterfaceState, (const string& interface, bool& enabled), (override)); + MOCK_METHOD(uint32_t, GetIPSettings, (string& interface, const string& ipversion, IPAddress& address), (override)); + MOCK_METHOD(uint32_t, SetIPSettings, (const string& interface, const IPAddress& address), (override)); + MOCK_METHOD(uint32_t, GetStunEndpoint, (string& endpoint, uint32_t& port, uint32_t& timeout, uint32_t& cacheLifetime), (const)); + MOCK_METHOD(uint32_t, SetStunEndpoint, (string const endpoint, const uint32_t port, const uint32_t timeout, const uint32_t cacheLifetime), (override)); + MOCK_METHOD(uint32_t, GetConnectivityTestEndpoints, (IStringIterator*& endpoints), (const)); + MOCK_METHOD(uint32_t, SetConnectivityTestEndpoints, (IStringIterator* const endpoints), (override)); + MOCK_METHOD(uint32_t, IsConnectedToInternet, (string& ipversion, string& interface, WPEFramework::Exchange::INetworkManager::InternetStatus& status), (override)); + MOCK_METHOD(uint32_t, GetCaptivePortalURI, (string& uri), (const)); + MOCK_METHOD(uint32_t, GetPublicIP, (string& interface, string& ipversion, string& ipaddress), (override)); + MOCK_METHOD(uint32_t, Ping, (const string ipversion, const string endpoint, const uint32_t count, const uint16_t timeout, const string guid, string& response), (override)); + MOCK_METHOD(uint32_t, Trace, (const string ipversion, const string endpoint, const uint32_t nqueries, const string guid, string& response), (override)); + MOCK_METHOD(uint32_t, StartWiFiScan, (const string& frequency, IStringIterator* const ssids), (override)); + MOCK_METHOD(uint32_t, StopWiFiScan, (), (override)); + MOCK_METHOD(uint32_t, GetKnownSSIDs, (IStringIterator*& ssids), (override)); + MOCK_METHOD(uint32_t, AddToKnownSSIDs, (const WiFiConnectTo& ssid), (override)); + MOCK_METHOD(uint32_t, RemoveKnownSSID, (const string& ssid), (override)); + MOCK_METHOD(uint32_t, WiFiConnect, (const WiFiConnectTo& ssid), (override)); + MOCK_METHOD(uint32_t, WiFiDisconnect, (), (override)); + MOCK_METHOD(uint32_t, GetConnectedSSID, (WiFiSSIDInfo& ssidInfo), (override)); + MOCK_METHOD(uint32_t, StartWPS, (const WiFiWPS& method, const string& pin), (override)); + MOCK_METHOD(uint32_t, StopWPS, (), (override)); + MOCK_METHOD(uint32_t, GetWifiState, (WPEFramework::Exchange::INetworkManager::WiFiState& state), (override)); + MOCK_METHOD(uint32_t, GetWiFiSignalQuality, (string& ssid, string& strength, string& noise, string& snr, WPEFramework::Exchange::INetworkManager::WiFiSignalQuality& quality), (override)); + MOCK_METHOD(uint32_t, GetSupportedSecurityModes, (ISecurityModeIterator*& modes), (const)); + MOCK_METHOD(uint32_t, SetLogLevel, (const Logging& level), (override)); + MOCK_METHOD(uint32_t, GetLogLevel, (Logging& level), (override)); + MOCK_METHOD(uint32_t, Configure, (WPEFramework::PluginHost::IShell* service), (override)); + MOCK_METHOD(uint32_t, Register, (WPEFramework::Exchange::INetworkManager::INotification* notification), (override)); + MOCK_METHOD(uint32_t, Unregister, (WPEFramework::Exchange::INetworkManager::INotification* notification), (override)); + MOCK_METHOD(uint32_t, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, Release, (), (const, override)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); +}; diff --git a/tests/mocks/LegacyNetworkMock.h b/tests/mocks/LegacyNetworkMock.h new file mode 100644 index 00000000..084690c8 --- /dev/null +++ b/tests/mocks/LegacyNetworkMock.h @@ -0,0 +1,65 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MOCKNETWORK_H +#define MOCKNETWORK_H + +#include +#include "Module.h" + +class StubNetwork : public WPEFramework::Plugin::Network { +public: + void onInterfaceStateChange(const JsonObject& parameters) { + WPEFramework::Plugin::Network::ReportonInterfaceStateChange(parameters); // Call the method on this object + } + + void onActiveInterfaceChange(const JsonObject& parameters) { + EXPECT_EQ(parameters["prevActiveInterface"].String(), "eth0"); + EXPECT_EQ(parameters["currentActiveInterface"].String(), "wlan0"); + WPEFramework::Plugin::Network::ReportonActiveInterfaceChange(parameters); + } + + void onIPAddressChange(const JsonObject& parameters) { + WPEFramework::Plugin::Network::ReportonIPAddressChange(parameters); + } + + void onInternetStatusChange(const JsonObject& parameters) { + EXPECT_EQ(parameters["state"].String(), "CONNECTED"); + EXPECT_EQ(parameters["status"].String(), "OK"); + WPEFramework::Plugin::Network::ReportonInternetStatusChange(parameters); + } + + string Information() const + { + WPEFramework::Plugin::Network::Information(); + return(string()); + } + + MOCK_METHOD(uint32_t, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, Release, (), (const, override)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); + MOCK_METHOD(const std::string, Initialize, (WPEFramework::PluginHost::IShell*), (override)); + MOCK_METHOD(void, Deinitialize, (WPEFramework::PluginHost::IShell*), (override)); + MOCK_METHOD(void, ReportonInterfaceStateChange, (const JsonObject&), ()); + MOCK_METHOD(void, ReportonActiveInterfaceChange, (const JsonObject&), ()); + MOCK_METHOD(void, ReportonIPAddressChange, (const JsonObject&), ()); + MOCK_METHOD(void, ReportonInternetStatusChange, (const JsonObject&), ()); + MOCK_METHOD(void, subscribeToEvents, (), ()); +}; +#endif diff --git a/tests/mocks/LegacyWiFiManagerMock.h b/tests/mocks/LegacyWiFiManagerMock.h new file mode 100644 index 00000000..5a44022a --- /dev/null +++ b/tests/mocks/LegacyWiFiManagerMock.h @@ -0,0 +1,54 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MOCKWIFIMANAGER_H +#define MOCKWIFIMANAGER_H + +#include +#include "Module.h" + +class StubWiFi : public WPEFramework::Plugin::WiFiManager { +public: + void onWiFiStateChange(const JsonObject& parameters) { + WPEFramework::Plugin::WiFiManager::onWiFiStateChange(parameters); // Call the method on this object + } + + void onAvailableSSIDs(const JsonObject& parameters) { + WPEFramework::Plugin::WiFiManager::onAvailableSSIDs(parameters); // Call the method on this object + } + + void onWiFiSignalQualityChange(const JsonObject& parameters) { + WPEFramework::Plugin::WiFiManager::onWiFiSignalQualityChange(parameters); // Call the method on this object + } + + string Information() const + { + WPEFramework::Plugin::WiFiManager::Information(); + return(string()); + } + + MOCK_METHOD(uint32_t, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, Release, (), (const, override)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); + MOCK_METHOD(const std::string, Initialize, (WPEFramework::PluginHost::IShell*), (override)); + MOCK_METHOD(void, Deinitialize, (WPEFramework::PluginHost::IShell*), (override)); + MOCK_METHOD(void, subscribeToEvents, (), ()); + MOCK_METHOD(uint32_t, cancelWPSPairing, (const JsonObject& parameters, JsonObject& response), ()); +}; +#endif diff --git a/tests/mocks/thunder/CommunicatorMock.h b/tests/mocks/thunder/CommunicatorMock.h index 60bfdcef..b689de20 100755 --- a/tests/mocks/thunder/CommunicatorMock.h +++ b/tests/mocks/thunder/CommunicatorMock.h @@ -39,7 +39,7 @@ class CommunicatorClientMock : public ICommunicatorClient class CommunicatorClientMock : public ICommunicatorClient { public: virtual ~CommunicatorClientMock() = default; - MOCK_METHOD(void, AddRef, (), (const)); + MOCK_METHOD(uint32_t, AddRef, (), (const)); MOCK_METHOD(uint32_t, Release, (), (const)); MOCK_METHOD(uint32_t, Open, (const uint32_t waitTime), (override)); MOCK_METHOD(void*, Open, (const std::string& className, const uint32_t version, const uint32_t waitTime), (override)); diff --git a/tests/mocks/thunder/DispatcherMock.h b/tests/mocks/thunder/DispatcherMock.h index 7a643f79..6ae2b7f5 100644 --- a/tests/mocks/thunder/DispatcherMock.h +++ b/tests/mocks/thunder/DispatcherMock.h @@ -27,7 +27,7 @@ class DispatcherMock: public WPEFramework::PluginHost::ILocalDispatcher{ public: virtual ~DispatcherMock() = default; - MOCK_METHOD(void, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, AddRef, (), (const, override)); MOCK_METHOD(uint32_t, Release, (), (const, override)); MOCK_METHOD(void*, QueryInterface, (const uint32_t interfaceNummer), (override)); MOCK_METHOD(void, Activate, (WPEFramework::PluginHost::IShell* service)); diff --git a/tests/mocks/thunder/IStringIteratorMock.h b/tests/mocks/thunder/IStringIteratorMock.h new file mode 100644 index 00000000..0477dbf2 --- /dev/null +++ b/tests/mocks/thunder/IStringIteratorMock.h @@ -0,0 +1,39 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MOCKSTRINGITERATOR_H +#define MOCKSTRINGITERATOR_H + +#include +#include "Module.h" + +template +class MockStringIterator : public WPEFramework::RPC::IStringIterator{ +public: + MOCK_METHOD(bool, Next, (ELEMENT&), (override)); + MOCK_METHOD(bool, Previous, (ELEMENT&), (override)); + MOCK_METHOD(void, Reset, (uint32_t), (override)); + MOCK_METHOD(bool, IsValid, (), (const)); + MOCK_METHOD(uint32_t, Count, (), (const)); + MOCK_METHOD(ELEMENT, Current, (), (const)); + MOCK_METHOD(uint32_t, AddRef, (), (const)); + MOCK_METHOD(uint32_t, Release, (), (const)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); +}; +#endif diff --git a/tests/mocks/thunder/InterfaceIteratorMock.h b/tests/mocks/thunder/InterfaceIteratorMock.h new file mode 100644 index 00000000..42aff4e6 --- /dev/null +++ b/tests/mocks/thunder/InterfaceIteratorMock.h @@ -0,0 +1,38 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MOCKINTERFACEITERATOR_H +#define MOCKINTERFACEITERATOR_H + +#include +#include "Module.h" + +class MockIInterfaceDetailsIterator : public WPEFramework::Exchange::INetworkManager::IInterfaceDetailsIterator { +public: + MOCK_METHOD(bool, Next, (WPEFramework::Exchange::INetworkManager::InterfaceDetails&), (override)); + MOCK_METHOD(bool, Previous, (WPEFramework::Exchange::INetworkManager::InterfaceDetails&), (override)); + MOCK_METHOD(void, Reset, (const uint32_t position), (override)); + MOCK_METHOD(bool, IsValid, (), (const, override)); + MOCK_METHOD(uint32_t, Count, (), (const, override)); + MOCK_METHOD(WPEFramework::Exchange::INetworkManager::InterfaceDetails, Current, (), (const, override)); + MOCK_METHOD(uint32_t, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, Release, (), (const, override)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); +}; +#endif diff --git a/tests/mocks/thunder/mockauthservices.h b/tests/mocks/thunder/mockauthservices.h index 9a696ff5..35e522a9 100644 --- a/tests/mocks/thunder/mockauthservices.h +++ b/tests/mocks/thunder/mockauthservices.h @@ -24,64 +24,13 @@ #include "Module.h" -class MockAuthService : public WPEFramework::Exchange::IAuthService { -public: - virtual ~MockAuthService() = default; - MOCK_METHOD(uint32_t, GetActivationStatus, (ActivationStatusResult&), (override)); - MOCK_METHOD(uint32_t, SetActivationStatus, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, ClearAuthToken, (SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, ClearSessionToken, (SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, ClearServiceAccessToken, (SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, ClearLostAndFoundAccessToken, (SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, ClearServiceAccountId, (SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, ClearCustomProperties, (SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetCustomProperties, (std::string&, bool&), (override)); - MOCK_METHOD(uint32_t, SetCustomProperties, (const std::string&, bool&), (override)); - MOCK_METHOD(uint32_t, GetAlternateIds, (std::string&, std::string&, bool&), (override)); - MOCK_METHOD(uint32_t, SetAlternateIds, (const std::string&, std::string&, bool&), (override)); - MOCK_METHOD(uint32_t, GetTransitionData, (std::string&, std::string&, bool&), (override)); - MOCK_METHOD(void, AddRef, (), (const, override)); - MOCK_METHOD(uint32_t, Release, (), (const, override)); - MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); - MOCK_METHOD(uint32_t, Register, (IAuthService::INotification*), (override)); - MOCK_METHOD(uint32_t, Unregister, (IAuthService::INotification*), (override)); - MOCK_METHOD(uint32_t, Configure, (), (override)); - MOCK_METHOD(uint32_t, GetInfo, (GetInfoResult&), (override)); - MOCK_METHOD(uint32_t, GetDeviceInfo, (GetDeviceInfoResult&), (override)); - MOCK_METHOD(uint32_t, GetDeviceId, (GetDeviceIdResult&), (override)); - MOCK_METHOD(uint32_t, SetDeviceId, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, SetPartnerId, (const std::string&, SetPartnerIdResult&), (override)); - MOCK_METHOD(uint32_t, GetAuthToken, (const bool, const bool, GetAuthTokenResult&), (override)); - MOCK_METHOD(uint32_t, GetSessionToken, (GetSessionTokenResult&), (override)); - MOCK_METHOD(uint32_t, SetSessionToken, (const int32_t&, const std::string&, uint32_t, const std::string&, const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetServiceAccessToken, (GetServiceAccessTokenResult&), (override)); - MOCK_METHOD(uint32_t, SetServiceAccessToken, (const int32_t&, const std::string&, uint32_t, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetServiceAccountId, (GetServiceAccountIdResult&), (override)); - MOCK_METHOD(uint32_t, SetServiceAccountId, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, SetAuthIdToken, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, Ready, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetBootstrapProperty, (const std::string&, GetBootstrapPropResult&), (override)); - MOCK_METHOD(uint32_t, ActivationStarted, (SuccessResult&), (override)); - MOCK_METHOD(uint32_t, ActivationComplete, (SuccessResult&), (override)); - MOCK_METHOD(uint32_t, GetLostAndFoundAccessToken, (std::string&, std::string&, bool&), (override)); - MOCK_METHOD(uint32_t, SetLostAndFoundAccessToken, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetXDeviceId, (GetXDeviceIdResult&), (override)); - MOCK_METHOD(uint32_t, SetXDeviceId, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetExperience, (GetExpResult&), (override)); - MOCK_METHOD(uint32_t, SetExperience, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetXifaId, (GetxifaIdResult&), (override)); - MOCK_METHOD(uint32_t, SetXifaId, (const std::string&, SuccessMsgResult&), (override)); - MOCK_METHOD(uint32_t, GetAdvtOptOut, (AdvtOptOutResult&), (override)); - MOCK_METHOD(uint32_t, SetAdvtOptOut, (const bool&, SuccessMsgResult&), (override)); -}; - class MockIAuthenticate : public WPEFramework::PluginHost::IAuthenticate { public: MOCK_METHOD(void*, QueryInterfaceByCallsign, (const uint32_t, const string&)); MOCK_METHOD(uint32_t, CreateToken, (uint16_t, const uint8_t*, std::string&)); MOCK_METHOD(uint32_t, Release, (), (const, override)); MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); - MOCK_METHOD(void, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, AddRef, (), (const, override)); MOCK_METHOD(WPEFramework::PluginHost::ISecurity*, Officer, (const std::string& token), (override)); }; #endif diff --git a/tests/patches/thunder/Remove-SmartLinkType.patch b/tests/patches/thunder/Remove-SmartLinkType.patch deleted file mode 100644 index ecf95858..00000000 --- a/tests/patches/thunder/Remove-SmartLinkType.patch +++ /dev/null @@ -1,21 +0,0 @@ -diff --git a/Source/websocket/JSONRPCLink.h b/Source/websocket/JSONRPCLink.h -index 9652d7ec..aad19ab1 100644 ---- a/Source/websocket/JSONRPCLink.h -+++ b/Source/websocket/JSONRPCLink.h -@@ -1235,16 +1235,6 @@ namespace WPEFramework { - } - - public: -- template -- uint32_t Subscribe(const uint32_t waitTime, const string& eventName, const METHOD& method) -- { -- return Subscribe(waitTime, eventName, method); -- } -- template -- uint32_t Subscribe(const uint32_t waitTime, const string& eventName, const METHOD& method, REALOBJECT* objectPtr) -- { -- return Subscribe(waitTime, eventName, method, objectPtr); -- } - bool IsActivated() - { - return (_state == ACTIVATED); diff --git a/tests/patches/thunder/SubscribeStub.patch b/tests/patches/thunder/SubscribeStub.patch new file mode 100644 index 00000000..91d16a77 --- /dev/null +++ b/tests/patches/thunder/SubscribeStub.patch @@ -0,0 +1,21 @@ +diff --git a/Source/websocket/JSONRPCLink.h b/Source/websocket/JSONRPCLink.h +--- a/Source/websocket/JSONRPCLink.h 2025-07-21 11:11:43.178011151 -0400 ++++ b/Source/websocket/JSONRPCLink.h 2025-07-21 11:13:11.330611722 -0400 +@@ -1238,12 +1238,15 @@ namespace WPEFramework { + template + uint32_t Subscribe(const uint32_t waitTime, const string& eventName, const METHOD& method) + { +- return Subscribe(waitTime, eventName, method); ++ const string parameters("{ \"event\": \"" + eventName + "\"}"); ++ if (eventName.empty() == false) ++ method(parameters); ++ return 0; + } + template + uint32_t Subscribe(const uint32_t waitTime, const string& eventName, const METHOD& method, REALOBJECT* objectPtr) + { +- return Subscribe(waitTime, eventName, method, objectPtr); ++ return 0; + } + bool IsActivated() + {