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/CHANGELOG.md b/CHANGELOG.md index 81279c2b..522fd606 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,12 @@ All notable changes to this RDK Service will be documented in this file. * Changes in CHANGELOG should be updated when commits are added to the main or release branches. There should be one CHANGELOG entry per JIRA Ticket. This is not enforced on sprint branches since there could be multiple changes for the same JIRA ticket during development. +## [0.23.0] - 2025-07-30 +### Added +- Added L1/L2 workflow for LegacyNetwork, LegacyWiFi and NetworkManager Plugins +- Fixed RemoveKnownSSID method to handle the invalid inputs +- Fixed the logging in GetIPSettings + ## [0.22.0] - 2025-07-14 ### Fixed - Fixed trigger point for the connectivity monitoring diff --git a/CMakeLists.txt b/CMakeLists.txt index efcea13f..6c6558d1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,7 +23,7 @@ find_package(WPEFramework) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake") set(VERSION_MAJOR 0) -set(VERSION_MINOR 22) +set(VERSION_MINOR 23) set(VERSION_PATCH 0) add_compile_definitions(NETWORKMANAGER_MAJOR_VERSION=${VERSION_MAJOR}) diff --git a/definition/NetworkManager.json b/definition/NetworkManager.json index de469b88..2dd3eddb 100644 --- a/definition/NetworkManager.json +++ b/definition/NetworkManager.json @@ -9,7 +9,7 @@ "status": "development", "description": "A Unified `NetworkManager` plugin that allows you to manage Ethernet and Wifi interfaces on the device.", "sourcelocation": "https://github.com/rdkcentral/networkmanager/blob/main/definition/NetworkManager.json", - "version": "0.22.0" + "version": "0.23.0" }, "definitions": { "success": { diff --git a/docs/NetworkManagerPlugin.md b/docs/NetworkManagerPlugin.md index fd7a1b44..8f30d423 100644 --- a/docs/NetworkManagerPlugin.md +++ b/docs/NetworkManagerPlugin.md @@ -2,7 +2,7 @@ # NetworkManager Plugin -**Version: 0.22.0** +**Version: 0.23.0** **Status: :white_circle::white_circle::white_circle:** @@ -23,7 +23,7 @@ org.rdk.NetworkManager interface for Thunder framework. ## Scope -This document describes purpose and functionality of the org.rdk.NetworkManager interface (version 0.22.0). It includes detailed specification about its methods provided and notifications sent. +This document describes purpose and functionality of the org.rdk.NetworkManager interface (version 0.23.0). It includes detailed specification about its methods provided and notifications sent. ## Case Sensitivity 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() + {