1 /*
2 * Copyright (c) 2025 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 #include <gtest/gtest.h>
17 #include "allowed_wifi_list_plugin.h"
18 #include "edm_ipc_interface_code.h"
19 #include "iplugin_manager.h"
20 #include "plugin_singleton.h"
21 #include "utils.h"
22
23 using namespace testing::ext;
24 using namespace testing;
25
26 namespace OHOS {
27 namespace EDM {
28 namespace TEST {
29
30 const std::string SSID_1 = "wifi_name1";
31 const std::string SSID_2 = "wifi_name2";
32 const std::string BSSID_1 = "68:77:24:77:A6:D7";
33 const std::string BSSID_2 = "68:77:24:77:A6:D9";
34
35 class AllowedWifiListPluginTest : public testing::Test {
36 protected:
37 static void SetUpTestSuite(void);
38
39 static void TearDownTestSuite(void);
40 };
SetUpTestSuite(void)41 void AllowedWifiListPluginTest::SetUpTestSuite(void)
42 {
43 Utils::SetEdmInitialEnv();
44 }
45
TearDownTestSuite(void)46 void AllowedWifiListPluginTest::TearDownTestSuite(void)
47 {
48 Utils::ResetTokenTypeAndUid();
49 ASSERT_TRUE(Utils::IsOriginalUTEnv());
50 std::cout << "now ut process is original ut env : " << Utils::IsOriginalUTEnv() << std::endl;
51 }
52
53 /**
54 * @tc.name: TestOnSetPolicyEmpty
55 * @tc.desc: Test AllowWifiListPlugin::OnSetPolicy function when policy is empty.
56 * @tc.type: FUNC
57 */
58 HWTEST_F(AllowedWifiListPluginTest, TestOnSetPolicyEmpty, TestSize.Level1)
59 {
60 AllowWifiListPlugin plugin;
61 std::vector<WifiId> policyData;
62 std::vector<WifiId> currentData;
63 std::vector<WifiId> mergeData;
64 ErrCode ret = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
65 ASSERT_TRUE(ret == ERR_OK);
66 }
67
68 /**
69 * @tc.name: TestOnSetPolicyWithDataAndCurrentData
70 * @tc.desc: Test AllowWifiListPlugin::OnSetPolicy function when policy has value and current data is empty.
71 * @tc.type: FUNC
72 */
73 HWTEST_F(AllowedWifiListPluginTest, TestOnSetPolicyWithDataAndCurrentData, TestSize.Level1)
74 {
75 AllowWifiListPlugin plugin;
76 std::vector<WifiId> policyData;
77 WifiId id1;
78 id1.SetSsid(SSID_1);
79 id1.SetBssid(BSSID_1);
80 policyData.emplace_back(id1);
81 std::vector<WifiId> currentData;
82 WifiId id2;
83 id2.SetSsid(SSID_2);
84 id2.SetBssid(BSSID_2);
85 policyData.emplace_back(id2);
86 std::vector<WifiId> mergeData;
87 ErrCode ret = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
88 ASSERT_TRUE(ret == ERR_OK);
89 }
90
91 /**
92 * @tc.name: TestOnSetPolicyWithDataWithoutCurrentData
93 * @tc.desc: Test AllowWifiListPlugin::OnSetPolicy function when policy has value and current data.
94 * @tc.type: FUNC
95 */
96 HWTEST_F(AllowedWifiListPluginTest, TestOnSetPolicyWithDataWithoutCurrentData, TestSize.Level1)
97 {
98 AllowWifiListPlugin plugin;
99 std::vector<WifiId> policyData;
100 WifiId id;
101 id.SetSsid(SSID_1);
102 id.SetBssid(BSSID_1);
103 policyData.emplace_back(id);
104 std::vector<WifiId> currentData;
105 std::vector<WifiId> mergeData;
106 ErrCode ret = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
107 ASSERT_TRUE(ret == ERR_OK);
108 }
109
110 /**
111 * @tc.name: TestOnSetPolicyWithLargeData
112 * @tc.desc: Test AllowWifiListPlugin::OnSetPolicy data is too large.
113 * @tc.type: FUNC
114 */
115 HWTEST_F(AllowedWifiListPluginTest, TestOnSetPolicyWithDataIsTooLarge, TestSize.Level1)
116 {
117 AllowWifiListPlugin plugin;
118 std::vector<WifiId> policyData;
119 for (int i = 0; i < 200; ++i) {
120 WifiId id;
121 id.SetSsid(std::to_string(i));
122 id.SetBssid(BSSID_1);
123 policyData.emplace_back(id);
124 }
125 std::vector<WifiId> currentData;
126 std::vector<WifiId> mergeData;
127 ErrCode ret = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
128 ASSERT_TRUE(ret == ERR_OK);
129 WifiId id2;
130 id2.SetSsid(SSID_1);
131 id2.SetBssid(BSSID_1);
132 policyData.emplace_back(id2);
133 ErrCode ret2 = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
134 ASSERT_TRUE(ret2 == EdmReturnErrCode::PARAM_ERROR);
135 }
136
137 /**
138 * @tc.name: TestOnSetPolicyWithErrorSsid
139 * @tc.desc: Test AllowWifiListPlugin::OnSetPolicy ssid length > 32.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(AllowedWifiListPluginTest, TestOnSetPolicyWithErrorSsid, TestSize.Level1)
143 {
144 AllowWifiListPlugin plugin;
145 std::vector<WifiId> policyData;
146 WifiId id;
147 id.SetSsid("131313131231231313123123123123123123123313131312312314214124141");
148 id.SetBssid(BSSID_1);
149 policyData.emplace_back(id);
150 std::vector<WifiId> currentData;
151 std::vector<WifiId> mergeData;
152 ErrCode ret = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
153 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
154 }
155
156 /**
157 * @tc.name: TestOnSetPolicyWithErrorBssid
158 * @tc.desc: Test AllowWifiListPlugin::OnSetPolicy bssid error.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(AllowedWifiListPluginTest, TestOnSetPolicyWithErrorBssid, TestSize.Level1)
162 {
163 AllowWifiListPlugin plugin;
164 std::vector<WifiId> policyData;
165 WifiId id;
166 id.SetSsid(SSID_1);
167 id.SetBssid("123");
168 policyData.emplace_back(id);
169 std::vector<WifiId> currentData;
170 std::vector<WifiId> mergeData;
171 ErrCode ret = plugin.OnSetPolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
172 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
173 }
174
175 /**
176 * @tc.name: TestOnRemovePolicyEmpty
177 * @tc.desc: Test AllowWifiListPlugin::OnRemovePolicy function when policy is empty.
178 * @tc.type: FUNC
179 */
180 HWTEST_F(AllowedWifiListPluginTest, TestOnRemovePolicyEmpty, TestSize.Level1)
181 {
182 AllowWifiListPlugin plugin;
183 std::vector<WifiId> policyData;
184 std::vector<WifiId> currentData;
185 std::vector<WifiId> mergeData;
186 ErrCode ret = plugin.OnRemovePolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
187 ASSERT_TRUE(ret == ERR_OK);
188 }
189
190 /**
191 * @tc.name: TestOnRemovePolicyWithDataAndCurrentData
192 * @tc.desc: Test AllowWifiListPlugin::OnRemovePolicy function when policy has value and current data is empty.
193 * @tc.type: FUNC
194 */
195 HWTEST_F(AllowedWifiListPluginTest, TestOnRemovePolicyWithDataAndCurrentData, TestSize.Level1)
196 {
197 AllowWifiListPlugin plugin;
198 std::vector<WifiId> policyData;
199 WifiId id1;
200 id1.SetSsid(SSID_1);
201 id1.SetBssid(BSSID_1);
202 policyData.emplace_back(id1);
203 std::vector<WifiId> currentData;
204 WifiId id2;
205 id2.SetSsid(SSID_2);
206 id2.SetBssid(BSSID_2);
207 policyData.emplace_back(id2);
208 std::vector<WifiId> mergeData;
209 ErrCode ret = plugin.OnRemovePolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
210 ASSERT_TRUE(ret == ERR_OK);
211 }
212
213 /**
214 * @tc.name: TestOnRemovePolicyWithLargeData
215 * @tc.desc: Test AllowWifiListPlugin::OnRemovePolicy data is too large.
216 * @tc.type: FUNC
217 */
218 HWTEST_F(AllowedWifiListPluginTest, TestOnRemovePolicyWithDataIsTooLarge, TestSize.Level1)
219 {
220 AllowWifiListPlugin plugin;
221 std::vector<WifiId> policyData;
222 for (int i = 0; i < 201; ++i) {
223 WifiId id;
224 id.SetSsid(std::to_string(i));
225 id.SetBssid(BSSID_1);
226 policyData.emplace_back(id);
227 }
228 std::vector<WifiId> currentData;
229 std::vector<WifiId> mergeData;
230 ErrCode ret = plugin.OnRemovePolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
231 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
232 }
233
234 /**
235 * @tc.name: TestOnRemovePolicyWithErrorSsid
236 * @tc.desc: Test AllowWifiListPlugin::OnRemovePolicy ssid length > 32.
237 * @tc.type: FUNC
238 */
239 HWTEST_F(AllowedWifiListPluginTest, TestOnRemovePolicyWithErrorSsid, TestSize.Level1)
240 {
241 AllowWifiListPlugin plugin;
242 std::vector<WifiId> policyData;
243 WifiId id;
244 id.SetSsid("131313131231231313123123123123123123123313131312312314214124141");
245 id.SetBssid(BSSID_1);
246 policyData.emplace_back(id);
247 std::vector<WifiId> currentData;
248 std::vector<WifiId> mergeData;
249 ErrCode ret = plugin.OnRemovePolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
250 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
251 }
252
253 /**
254 * @tc.name: TestOnRemovePolicyWithErrorBssid
255 * @tc.desc: Test AllowWifiListPlugin::OnRemovePolicy bssid error.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(AllowedWifiListPluginTest, TestOnRemovePolicyWithErrorBssid, TestSize.Level1)
259 {
260 AllowWifiListPlugin plugin;
261 std::vector<WifiId> policyData;
262 WifiId id;
263 id.SetSsid(SSID_1);
264 id.SetBssid("123");
265 policyData.emplace_back(id);
266 std::vector<WifiId> currentData;
267 std::vector<WifiId> mergeData;
268 ErrCode ret = plugin.OnRemovePolicy(policyData, currentData, mergeData, DEFAULT_USER_ID);
269 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
270 }
271
272 /**
273 * @tc.name: TestOnAdminRemovePolicyEmpty
274 * @tc.desc: Test AllowWifiListPlugin::OnAdminRemove function when policy is true.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(AllowedWifiListPluginTest, TestOnAdminRemovePolicyEmpty, TestSize.Level1)
278 {
279 AllowWifiListPlugin plugin;
280 std::string adminName{"testAdminName"};
281 std::vector<WifiId> policyData;
282 std::vector<WifiId> mergeData;
283 ErrCode ret = plugin.OnAdminRemove(adminName, policyData, mergeData, DEFAULT_USER_ID);
284 ASSERT_TRUE(ret == ERR_OK);
285 }
286
287 /**
288 * @tc.name: TestOnAdminRemoveFalse
289 * @tc.desc: Test AllowWifiListPlugin::OnAdminRemove function when policy is disabled.
290 * @tc.type: FUNC
291 */
292 HWTEST_F(AllowedWifiListPluginTest, TestOnAdminRemoveHasPolicy, TestSize.Level1)
293 {
294 AllowWifiListPlugin plugin;
295 std::string adminName{"testAdminName"};
296 std::vector<WifiId> policyData;
297 WifiId id;
298 id.SetSsid(SSID_1);
299 id.SetBssid(BSSID_1);
300 policyData.emplace_back(id);
301 std::vector<WifiId> mergeData;
302 ErrCode ret = plugin.OnAdminRemove(adminName, policyData, mergeData, DEFAULT_USER_ID);
303 ASSERT_TRUE(ret == ERR_OK);
304 }
305 }
306 }
307 }
308