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