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 #include <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "vendor_wlan_group.h"
20 #include "print_constant.h"
21 #include "print_log.h"
22 #include "mock/mock_print_service_ability.h"
23
24 namespace {
25 const int WAIT_TIME_MS = 100;
26 const std::string PRINTER_TEST_IP = "192.168.2.222";
27 const std::string PRINTER_TEST_GLOBAL_ID = "fwk.driver.wlan.group:192.168.2.222";
28 const std::string PRINTER_TEST_URI = "ipp://192.168.2.222:631";
29 const std::string PRINTER_TEST_PPDDTAT = "test_ppd_data";
30 const std::string PRINTER_TEST_UUID = "test_uuid";
31 }
32 using namespace testing;
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace Print {
37 class VendorWlanGroupTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase(void)45 void VendorWlanGroupTest::SetUpTestCase(void) {}
46
TearDownTestCase(void)47 void VendorWlanGroupTest::TearDownTestCase(void) {}
48
SetUp(void)49 void VendorWlanGroupTest::SetUp(void)
50 {
51 static int32_t testNo = 0;
52 PRINT_HILOGI("VendorWlanGroupTest_%{public}d", ++testNo);
53 }
54
TearDown(void)55 void VendorWlanGroupTest::TearDown(void) {}
56
57 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0001, TestSize.Level1)
58 {
59 MockPrintServiceAbility mock;
60 VendorManager vendorManager;
61 EXPECT_TRUE(vendorManager.Init(&mock, false));
62 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
63 EXPECT_EQ(vendorWlanGroup->parentVendorManager, &vendorManager);
64 }
65
66 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0002, TestSize.Level2)
67 {
68 std::string printerId = PRINTER_TEST_IP;
69 MockPrintServiceAbility mock;
70 VendorManager vendorManager;
71 EXPECT_TRUE(vendorManager.Init(&mock, false));
72 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
73 EXPECT_EQ(vendorWlanGroup->OnQueryCapability(printerId, 0), false);
74 vendorWlanGroup->parentVendorManager = nullptr;
75 EXPECT_EQ(vendorWlanGroup->OnQueryCapability(printerId, 0), false);
76 }
77
78 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0003, TestSize.Level2)
79 {
80 std::string printerId = PRINTER_TEST_IP;
81 MockPrintServiceAbility mock;
82 VendorManager vendorManager;
83 EXPECT_TRUE(vendorManager.Init(&mock, false));
84 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
85 EXPECT_EQ(vendorWlanGroup->OnQueryCapabilityByIp(printerId, "ipp"), false);
86 vendorWlanGroup->parentVendorManager = nullptr;
87 EXPECT_EQ(vendorWlanGroup->OnQueryCapabilityByIp(printerId, "ipp"), false);
88 }
89
90 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0004, TestSize.Level2)
91 {
92 std::string printerId = PRINTER_TEST_IP;
93 PrinterInfo info;
94 MockPrintServiceAbility mock;
95 VendorManager vendorManager;
96 EXPECT_TRUE(vendorManager.Init(&mock, false));
97 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
98 EXPECT_CALL(mock, AddVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(true));
99 EXPECT_EQ(vendorWlanGroup->OnPrinterDiscovered(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_NONE);
100 vendorWlanGroup->parentVendorManager = nullptr;
101 EXPECT_EQ(vendorWlanGroup->OnPrinterDiscovered(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_CALLBACK_NULL);
102 }
103
104 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0005, TestSize.Level2)
105 {
106 std::string printerId = PRINTER_TEST_IP;
107 PrinterInfo info;
108 MockPrintServiceAbility mock;
109 VendorManager vendorManager;
110 EXPECT_TRUE(vendorManager.Init(&mock, false));
111 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
112 EXPECT_CALL(mock, AddIpPrinterToSystemData(_, _)).WillRepeatedly(Return(true));
113 EXPECT_CALL(mock, UpdateVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(true));
114 vendorManager.SetConnectingPrinter(IP_AUTO, PRINTER_TEST_GLOBAL_ID);
115 EXPECT_EQ(vendorWlanGroup->OnUpdatePrinterToDiscovery(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_NONE);
116 vendorManager.SetConnectingPrinter(ID_AUTO, PRINTER_TEST_GLOBAL_ID);
117 EXPECT_EQ(vendorWlanGroup->OnUpdatePrinterToDiscovery(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_NONE);
118 vendorWlanGroup->parentVendorManager = nullptr;
119 EXPECT_EQ(vendorWlanGroup->OnUpdatePrinterToDiscovery(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_CALLBACK_NULL);
120 }
121
122 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0006, TestSize.Level2)
123 {
124 std::string printerId = PRINTER_TEST_IP;
125 MockPrintServiceAbility mock;
126 VendorManager vendorManager;
127 EXPECT_TRUE(vendorManager.Init(&mock, false));
128 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
129 EXPECT_EQ(vendorWlanGroup->OnPrinterRemoved(VENDOR_WLAN_GROUP, printerId), EXTENSION_ERROR_CALLBACK_FAIL);
130 vendorWlanGroup->parentVendorManager = nullptr;
131 EXPECT_EQ(vendorWlanGroup->OnPrinterRemoved(VENDOR_WLAN_GROUP, printerId), EXTENSION_ERROR_CALLBACK_NULL);
132 }
133
134 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0007, TestSize.Level2)
135 {
136 std::string printerId = PRINTER_TEST_IP;
137 MockPrintServiceAbility mock;
138 VendorManager vendorManager;
139 EXPECT_TRUE(vendorManager.Init(&mock, false));
140 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
141 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
142 vendorWlanGroup->parentVendorManager = nullptr;
143 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
144 }
145
146 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0008, TestSize.Level2)
147 {
148 std::string printerId = PRINTER_TEST_IP;
149 MockPrintServiceAbility mock;
150 VendorManager vendorManager;
151 EXPECT_TRUE(vendorManager.Init(&mock, false));
152 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
153 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
154 vendorWlanGroup->parentVendorManager = nullptr;
155 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
156 }
157
158 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0009, TestSize.Level2)
159 {
160 std::string printerId = PRINTER_TEST_IP;
161 MockPrintServiceAbility mock;
162 VendorManager vendorManager;
163 EXPECT_TRUE(vendorManager.Init(&mock, false));
164 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
165 vendorWlanGroup->SetConnectingPrinter(ID_AUTO, printerId);
166 EXPECT_EQ(vendorWlanGroup->parentVendorManager->isConnecting, true);
167 vendorWlanGroup->parentVendorManager = nullptr;
168 vendorWlanGroup->SetConnectingPrinter(ID_AUTO, printerId);
169 }
170
171 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0010, TestSize.Level2)
172 {
173 std::string printerId = PRINTER_TEST_IP;
174 MockPrintServiceAbility mock;
175 VendorManager vendorManager;
176 EXPECT_TRUE(vendorManager.Init(&mock, false));
177 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
178 EXPECT_EQ(vendorWlanGroup->OnPrinterPpdQueried(VENDOR_WLAN_GROUP, printerId, PRINTER_TEST_PPDDTAT), false);
179 vendorWlanGroup->parentVendorManager = nullptr;
180 EXPECT_EQ(vendorWlanGroup->OnPrinterPpdQueried(VENDOR_WLAN_GROUP, printerId, PRINTER_TEST_PPDDTAT), false);
181 }
182
183 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0011, TestSize.Level2)
184 {
185 std::string printerId = PRINTER_TEST_IP;
186 MockPrintServiceAbility mock;
187 VendorManager vendorManager;
188 EXPECT_TRUE(vendorManager.Init(&mock, false));
189 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
190 EXPECT_EQ(vendorWlanGroup->IsGroupDriver(printerId), false);
191 vendorWlanGroup->parentVendorManager = nullptr;
192 EXPECT_EQ(vendorWlanGroup->IsGroupDriver(printerId), false);
193 }
194
195 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0012, TestSize.Level2)
196 {
197 MockPrintServiceAbility mock;
198 VendorManager vendorManager;
199 EXPECT_TRUE(vendorManager.Init(&mock, false));
200 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
201 std::string printerId = PRINTER_TEST_IP;
202 std::string vendorName = VENDOR_BSUNI_DRIVER;
203 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), false);
204 vendorName = VENDOR_WLAN_GROUP;
205 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), false);
206 vendorWlanGroup->printerVendorGroupList_[printerId] = "";
207 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), false);
208 vendorWlanGroup->printerVendorGroupList_[printerId] = VENDOR_BSUNI_DRIVER;
209 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), true);
210 }
211
212 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0013, TestSize.Level2)
213 {
214 std::string printerId = PRINTER_TEST_GLOBAL_ID;
215 auto printerInfo = std::make_shared<PrinterInfo>();
216 MockPrintServiceAbility mock;
217 VendorManager vendorManager;
218 EXPECT_TRUE(vendorManager.Init(&mock, false));
219 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
220 EXPECT_CALL(mock, QueryDiscoveredPrinterInfoById(_)).WillOnce(Return(nullptr)).WillRepeatedly(Return(printerInfo));
221 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
222 printerInfo->SetOption("{\"bsunidriverSupport\": \"true\"}");
223 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), true);
224 printerInfo->SetOption("{\"bsunidriverSupport\": \"false\"}");
225 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
226 printerInfo->SetOption("{\"bsunidriverSupport\": \"need_gs\"}");
227 vendorWlanGroup->hasGs = false;
228 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
229 vendorWlanGroup->hasGs = true;
230 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), true);
231 vendorWlanGroup->parentVendorManager = nullptr;
232 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
233 }
234
235 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0014, TestSize.Level2)
236 {
237 MockPrintServiceAbility mock;
238 VendorManager vendorManager;
239 EXPECT_TRUE(vendorManager.Init(&mock, false));
240 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
241 std::string printerId = PRINTER_TEST_GLOBAL_ID;
242 vendorWlanGroup->RemoveGroupPrinterFromVendorGroupList(printerId);
243 vendorWlanGroup->printerVendorGroupList_[printerId] = VENDOR_BSUNI_DRIVER;
244 vendorWlanGroup->RemoveGroupPrinterFromVendorGroupList(printerId);
245 EXPECT_TRUE(vendorWlanGroup->printerVendorGroupList_.empty());
246 }
247
248 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0015, TestSize.Level2)
249 {
250 MockPrintServiceAbility mock;
251 VendorManager vendorManager;
252 EXPECT_TRUE(vendorManager.Init(&mock, false));
253 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
254 std::string printerId = PRINTER_TEST_GLOBAL_ID;
255 EXPECT_EQ(vendorWlanGroup->QueryVendorDriverByGroupPrinterId(printerId), "");
256 vendorWlanGroup->printerVendorGroupList_[printerId] = VENDOR_BSUNI_DRIVER;
257 EXPECT_EQ(vendorWlanGroup->QueryVendorDriverByGroupPrinterId(printerId), VENDOR_BSUNI_DRIVER);
258 }
259
260 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0016, TestSize.Level2)
261 {
262 MockPrintServiceAbility mock;
263 VendorManager vendorManager;
264 EXPECT_TRUE(vendorManager.Init(&mock, false));
265 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
266 std::string printerId = PRINTER_TEST_IP;
267 EXPECT_EQ(vendorWlanGroup->GetGroupPrinterId(printerId), PRINTER_TEST_IP);
268 vendorWlanGroup->groupPrinterIdMap_[printerId] = PRINTER_TEST_GLOBAL_ID;
269 EXPECT_EQ(vendorWlanGroup->GetGroupPrinterId(printerId), PRINTER_TEST_GLOBAL_ID);
270 }
271
272 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0017, TestSize.Level2)
273 {
274 std::string printerId = PRINTER_TEST_GLOBAL_ID;
275 MockPrintServiceAbility mock;
276 VendorManager vendorManager;
277 EXPECT_TRUE(vendorManager.Init(&mock, false));
278 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
279 vendorManager.SetConnectingPrinter(IP_AUTO, PRINTER_TEST_GLOBAL_ID);
280 EXPECT_EQ(vendorWlanGroup->CheckPrinterAddedByIp(printerId), true);
281 vendorManager.SetConnectingPrinter(ID_AUTO, PRINTER_TEST_GLOBAL_ID);
282 EXPECT_EQ(vendorWlanGroup->CheckPrinterAddedByIp(printerId), false);
283 vendorWlanGroup->parentVendorManager = nullptr;
284 EXPECT_EQ(vendorWlanGroup->CheckPrinterAddedByIp(printerId), false);
285 }
286
287 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0018, TestSize.Level2)
288 {
289 MockPrintServiceAbility mock;
290 VendorManager vendorManager;
291 EXPECT_TRUE(vendorManager.Init(&mock, false));
292 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
293 std::string printerId = PRINTER_TEST_IP;
294 EXPECT_CALL(mock, RemoveVendorPrinterFromDiscovery(_, _)).WillRepeatedly(Return(true));
295 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_IP);
296 EXPECT_EQ(vendorWlanGroup->groupPrinterIdMap_[printerId], PRINTER_TEST_IP);
297 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_IP);
298 EXPECT_EQ(vendorWlanGroup->groupPrinterIdMap_[printerId], PRINTER_TEST_IP);
299 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_GLOBAL_ID);
300 EXPECT_EQ(vendorWlanGroup->groupPrinterIdMap_[printerId], PRINTER_TEST_GLOBAL_ID);
301 }
302
303 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0019, TestSize.Level2)
304 {
305 MockPrintServiceAbility mock;
306 VendorManager vendorManager;
307 EXPECT_TRUE(vendorManager.Init(&mock, false));
308 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
309 std::string printerId = PRINTER_TEST_IP;
310 EXPECT_EQ(vendorWlanGroup->HasGroupPrinter(printerId), false);
311 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_IP);
312 EXPECT_EQ(vendorWlanGroup->HasGroupPrinter(printerId), true);
313 }
314
315 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0020, TestSize.Level2)
316 {
317 MockPrintServiceAbility mock;
318 VendorManager vendorManager;
319 EXPECT_TRUE(vendorManager.Init(&mock, false));
320 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
321 std::string printerId = PRINTER_TEST_IP;
322 PrinterInfo info;
323 info.SetPrinterId(printerId);
324 EXPECT_CALL(mock, RemoveVendorPrinterFromDiscovery(_, _)).WillRepeatedly(Return(true));
325 EXPECT_EQ(vendorWlanGroup->ConvertPrinterInfoId(info).GetPrinterId(), PRINTER_TEST_IP);
326 info.SetPrinterUuid(PRINTER_TEST_UUID);
327 EXPECT_EQ(vendorWlanGroup->ConvertPrinterInfoId(info).GetPrinterId(), PRINTER_TEST_UUID);
328 }
329
330 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0021, TestSize.Level2)
331 {
332 MockPrintServiceAbility mock;
333 VendorManager vendorManager;
334 EXPECT_TRUE(vendorManager.Init(&mock, false));
335 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
336 PrinterInfo info;
337 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
338 info.SetUri("test_uri");
339 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
340 info.SetUri("test_uri://");
341 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
342 info.SetUri("test_uri://");
343 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
344 info.SetUri(PRINTER_TEST_URI);
345 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), PRINTER_TEST_IP);
346 }
347
348 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0022, TestSize.Level2)
349 {
350 std::string printerId = PRINTER_TEST_GLOBAL_ID;
351 MockPrintServiceAbility mock;
352 VendorManager vendorManager;
353 EXPECT_TRUE(vendorManager.Init(&mock, false));
354 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
355 EXPECT_CALL(mock, QueryPrinterInfoByPrinterId(_, _))
356 .WillOnce(Return(E_PRINT_SERVER_FAILURE)).WillRepeatedly(Return(E_PRINT_NONE));
357 EXPECT_EQ(vendorWlanGroup->MonitorPrinterStatus(printerId, true), false);
358 EXPECT_EQ(vendorWlanGroup->MonitorPrinterStatus(printerId, true), false);
359 vendorWlanGroup->parentVendorManager = nullptr;
360 EXPECT_EQ(vendorWlanGroup->MonitorPrinterStatus(printerId, true), false);
361 }
362
363 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0023, TestSize.Level2)
364 {
365 std::string printerId = PRINTER_TEST_GLOBAL_ID;
366 PrinterVendorStatus state;
367 MockPrintServiceAbility mock;
368 VendorManager vendorManager;
369 EXPECT_TRUE(vendorManager.Init(&mock, false));
370 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
371 EXPECT_CALL(mock, OnVendorStatusUpdate(_, _, _)).WillRepeatedly(Return(true));
372 EXPECT_EQ(vendorWlanGroup->OnPrinterStatusChanged(VENDOR_WLAN_GROUP, printerId, state), true);
373 vendorWlanGroup->parentVendorManager = nullptr;
374 EXPECT_EQ(vendorWlanGroup->OnPrinterStatusChanged(VENDOR_WLAN_GROUP, printerId, state), false);
375 }
376 } // namespace Print
377 } // namespace OHOS