1/*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#define private public
17#define protected public
18
19#include <gtest/gtest.h>
20
21#include "mock/mock_sim_manager.h"
22#include "core_manager_inner.h"
23#include "cellular_data_handler.h"
24#include "cellular_data_incall_observer.h"
25#include "cellular_data_setting_observer.h"
26#include "cellular_data_rdb_observer.h"
27#include "cellular_data_roaming_observer.h"
28#include "cellular_data_settings_rdb_helper.h"
29
30namespace OHOS {
31namespace Telephony {
32using namespace testing::ext;
33using ::testing::_;
34using ::testing::Mock;
35using ::testing::Return;
36
37class CellularDataObserverTest : public testing::Test {
38public:
39    CellularDataObserverTest() = default;
40    ~CellularDataObserverTest() = default;
41
42    static void TearDownTestCase()
43    {
44        if (CoreManagerInner::GetInstance().simManager_ != nullptr) {
45            CoreManagerInner::GetInstance().simManager_ = nullptr;
46            std::cout << "CellularDataObserverTest set simManager_ nullptr" << std::endl;
47        }
48    }
49
50    static std::shared_ptr<CellularDataHandler> createCellularDataHandler()
51    {
52        EventFwk::CommonEventSubscribeInfo subscriberInfo;
53        subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
54        std::shared_ptr<CellularDataHandler> cellularDataHandler =
55            std::make_shared<CellularDataHandler>(subscriberInfo, 0);
56        return cellularDataHandler;
57    }
58};
59
60HWTEST_F(CellularDataObserverTest, CellularDataIncallObserver_01, Function | MediumTest | Level1)
61{
62    std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr;
63    auto cellularDataIncallObserver = std::make_shared<CellularDataIncallObserver>(cellularDataHandler);
64    cellularDataIncallObserver->OnChange();
65    ASSERT_TRUE(cellularDataHandler == nullptr);
66
67    // GetValue success, cellularDataHandler is nullptr
68    std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
69    Uri uri(CELLULAR_DATA_SETTING_DATA_INCALL_URI);
70    ASSERT_TRUE(settingHelper->PutValue(uri, CELLULAR_DATA_COLUMN_INCALL, 1) == TELEPHONY_ERR_SUCCESS);
71    cellularDataIncallObserver->OnChange();
72    ASSERT_TRUE(cellularDataHandler == nullptr);
73
74    // GetValue success, cellularDataHandler is not nullptr
75    cellularDataHandler = CellularDataObserverTest::createCellularDataHandler();
76    cellularDataIncallObserver = std::make_shared<CellularDataIncallObserver>(cellularDataHandler);
77    cellularDataIncallObserver->OnChange();
78    ASSERT_FALSE(cellularDataHandler == nullptr);
79}
80
81HWTEST_F(CellularDataObserverTest, CellularDataRdbObserver_02, Function | MediumTest | Level1)
82{
83    std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr;
84    auto cellularDataRdbObserver = std::make_shared<CellularDataRdbObserver>(cellularDataHandler);
85    cellularDataRdbObserver->OnChange();
86    ASSERT_TRUE(cellularDataHandler == nullptr);
87
88    // cellularDataHandler is not nullptr
89    cellularDataHandler = CellularDataObserverTest::createCellularDataHandler();
90    cellularDataRdbObserver = std::make_shared<CellularDataRdbObserver>(cellularDataHandler);
91    cellularDataRdbObserver->OnChange();
92    ASSERT_FALSE(cellularDataHandler == nullptr);
93}
94
95HWTEST_F(CellularDataObserverTest, CellularDataRoamingObserver_03, Function | MediumTest | Level1)
96{
97    // mock sim manager
98    ASSERT_TRUE(CoreManagerInner::GetInstance().simManager_ == nullptr);
99    MockSimManager *mockSimManager = new MockSimManager();
100    std::shared_ptr<MockSimManager> mockSimManagerPtr(mockSimManager);
101    CoreManagerInner::GetInstance().OnInit(nullptr, mockSimManagerPtr, nullptr);
102    ASSERT_FALSE(CoreManagerInner::GetInstance().simManager_ == nullptr);
103    ASSERT_EQ(CoreManagerInner::GetInstance().simManager_, mockSimManagerPtr);
104
105    // get sim id failed
106    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(-1));
107    std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr;
108    auto cellularDataRoamingObserver = std::make_shared<CellularDataRoamingObserver>(cellularDataHandler, 0);
109    cellularDataRoamingObserver->OnChange();
110    ASSERT_TRUE(cellularDataHandler == nullptr);
111
112    // get sim id success, GetValue failed
113    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1));
114    cellularDataRoamingObserver->OnChange();
115    ASSERT_TRUE(cellularDataHandler == nullptr);
116
117    // get sim id success, GetValue success, cellularDataHandler is nullptr
118    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1));
119    std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
120    Uri uri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(1));
121    std::string col = std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(1);
122    ASSERT_TRUE(settingHelper->PutValue(uri, col, 1) == TELEPHONY_ERR_SUCCESS);
123    cellularDataRoamingObserver->OnChange();
124    ASSERT_TRUE(cellularDataHandler == nullptr);
125
126    // get sim id success, GetValue success, cellularDataHandler is nullptr
127    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1));
128    cellularDataHandler = CellularDataObserverTest::createCellularDataHandler();
129    cellularDataRoamingObserver = std::make_shared<CellularDataRoamingObserver>(cellularDataHandler, 0);
130    cellularDataRoamingObserver->OnChange();
131    ASSERT_FALSE(cellularDataHandler == nullptr);
132
133    Mock::VerifyAndClearExpectations(mockSimManager);
134}
135
136HWTEST_F(CellularDataObserverTest, CellularDataSettingObserver_04, Function | MediumTest | Level1)
137{
138    std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr;
139    auto cellularDataSettingObserver = std::make_shared<CellularDataSettingObserver>(cellularDataHandler);
140    cellularDataSettingObserver->OnChange();
141    ASSERT_TRUE(cellularDataHandler == nullptr);
142
143    // GetValue success, cellularDataHandler is nullptr
144    std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
145    Uri uri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
146    ASSERT_TRUE(settingHelper->PutValue(uri, CELLULAR_DATA_COLUMN_ENABLE, 1) == TELEPHONY_ERR_SUCCESS);
147    cellularDataSettingObserver->OnChange();
148    ASSERT_TRUE(cellularDataHandler == nullptr);
149
150    // GetValue success, cellularDataHandler is not nullptr
151    cellularDataHandler = CellularDataObserverTest::createCellularDataHandler();
152    cellularDataSettingObserver = std::make_shared<CellularDataSettingObserver>(cellularDataHandler);
153    cellularDataSettingObserver->OnChange();
154    ASSERT_FALSE(cellularDataHandler == nullptr);
155}
156
157}  // namespace Telephony
158}  // namespace OHOS