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 #include <vector>
18 #include <string>
19 #include <map>
20 #include "printer_info.h"
21 #include "iprint_callback.h"
22 #define private public
23 #include "print_user_data.h"
24 #undef private
25 #include "print_constant.h"
26 #include "print_log.h"
27 #include "mock_print_callback_stub.h"
28 
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Print {
33 
34 class PrintUserDataTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40 };
41 
SetUpTestCase(void)42 void PrintUserDataTest::SetUpTestCase(void) {}
43 
TearDownTestCase(void)44 void PrintUserDataTest::TearDownTestCase(void) {}
45 
SetUp(void)46 void PrintUserDataTest::SetUp(void)
47 {
48     static int32_t testNo = 0;
49     PRINT_HILOGI("PrintUserDataTest_%{public}d", ++testNo);
50 }
51 
TearDown(void)52 void PrintUserDataTest::TearDown(void) {}
53 
54 /**
55  * @tc.name: PrintServiceStubTest_0001
56  * @tc.desc: Verify the capability function.
57  * @tc.type: FUNC
58  * @tc.require:
59  */
60 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0001, TestSize.Level1)
61 {
62     std::string type = "111";
63     sptr<IPrintCallback> listener = nullptr;
64     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
65     userData->RegisterPrinterCallback(type, listener);
66     EXPECT_EQ(userData->registeredListeners_.size(), 1);
67 }
68 
69 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0002, TestSize.Level1)
70 {
71     std::string type = "111";
72     sptr<IPrintCallback> listener = nullptr;
73     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
74     userData->RegisterPrinterCallback(type, listener);
75     userData->UnregisterPrinterCallback(type);
76     EXPECT_EQ(userData->registeredListeners_.size(), 0);
77 }
78 
79 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0003, TestSize.Level1)
80 {
81     std::string type = "111";
82     std::string type2 = "222";
83     sptr<IPrintCallback> listener = nullptr;
84     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
85     userData->RegisterPrinterCallback(type, listener);
86     userData->UnregisterPrinterCallback(type2);
87     EXPECT_EQ(userData->registeredListeners_.size(), 1);
88 }
89 
90 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0004, TestSize.Level1)
91 {
92     std::string type = "111";
93     sptr<IPrintCallback> listener = nullptr;
94     PrinterInfo info;
95     int event = 0;
96     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
97     userData->RegisterPrinterCallback(type, listener);
98     userData->SendPrinterEvent(type, event, info);
99     EXPECT_EQ(userData->registeredListeners_.size(), 1);
100 }
101 
102 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0005, TestSize.Level1)
103 {
104     std::string type = "111";
105     std::string type2 = "222";
106     sptr<IPrintCallback> listener = nullptr;
107     PrinterInfo info;
108     int event = 0;
109     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
110     userData->RegisterPrinterCallback(type, listener);
111     userData->SendPrinterEvent(type2, event, info);
112     EXPECT_EQ(userData->registeredListeners_.size(), 1);
113 }
114 
115 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0006, TestSize.Level1)
116 {
117     std::string type = "111";
118     std::string type2 = "222";
119     sptr<IPrintCallback> listener = nullptr;
120     sptr<IPrintCallback> newListener = nullptr;
121     PrinterInfo info;
122     int event = 0;
123     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
124     userData->RegisterPrinterCallback(type, listener);
125     userData->RegisterPrinterCallback(type2, newListener);
126     userData->SendPrinterEvent(type, event, info);
127 }
128 
129 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0007, TestSize.Level1)
130 {
131     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
132     std::string jobId = "1";
133     PrintJob findPrintJob;
134     EXPECT_EQ(userData->QueryPrintJobById(jobId, findPrintJob), E_PRINT_INVALID_PRINTJOB);
135     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
136     userData->AddToPrintJobList(jobId, printJob);
137     EXPECT_EQ(userData->QueryPrintJobById(jobId, findPrintJob), E_PRINT_NONE);
138     jobId = "2";
139     EXPECT_EQ(userData->QueryPrintJobById(jobId, findPrintJob), E_PRINT_INVALID_PRINTJOB);
140 }
141 
142 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0008, TestSize.Level1)
143 {
144     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
145     std::string jobOrderId = "0";
146     std::string jobId = "1";
147     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
148     userData->AddToPrintJobList(jobId, printJob);
149     std::string newJobId = "2";
150     userData->UpdateQueuedJobList(newJobId, printJob, jobOrderId);
151     EXPECT_EQ(userData->queuedJobList_[newJobId], nullptr);
152     EXPECT_EQ(userData->jobOrderList_[jobOrderId], "");
153 }
154 
155 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0009, TestSize.Level1)
156 {
157     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
158     std::string jobOrderId = "0";
159     std::string jobId = "1";
160     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
161     userData->AddToPrintJobList(jobId, printJob);
162     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
163     std::vector<PrintJob> printJobs;
164     EXPECT_EQ(userData->QueryAllPrintJob(printJobs), E_PRINT_NONE);
165     printJob = nullptr;
166     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
167 }
168 
169 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0010, TestSize.Level1)
170 {
171     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
172     std::string type = "111";
173     sptr<IPrintCallback> listener = new (std::nothrow) DummyPrintCallbackStub();
174     PrinterInfo info;
175     int event = 0;
176     userData->RegisterPrinterCallback(type, listener);
177     userData->SendPrinterEvent(type, event, info);
178 }
179 
180 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0011, TestSize.Level1)
181 {
182     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
183     std::string jobOrderId = "0";
184     std::string jobId = "1";
185     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
186     userData->AddToPrintJobList(jobId, printJob);
187     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
188     EXPECT_EQ(userData->queuedJobList_[jobId], printJob);
189     EXPECT_EQ(userData->jobOrderList_[jobOrderId], jobId);
190     userData->AddToPrintJobList(jobId, printJob);
191     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
192     EXPECT_EQ(userData->queuedJobList_[jobId], printJob);
193     EXPECT_EQ(userData->jobOrderList_[jobOrderId], jobId);
194 }
195 
196 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0012, TestSize.Level1)
197 {
198     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
199     std::string jobOrderId = "0";
200     std::string jobId = "1";
201     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
202     userData->jobOrderList_.insert(std::make_pair(jobOrderId, jobId));
203     std::vector<PrintJob> printJobs;
204     userData->QueryAllPrintJob(printJobs);
205 }
206 
207 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0013, TestSize.Level1)
208 {
209     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
210     int32_t userId = 101;
211     userData->SetUserId(userId);
212     EXPECT_EQ(userData->userId_, userId);
213 }
214 
215 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0014, TestSize.Level1)
216 {
217     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
218     std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-0105";
219     userData->SetLastUsedPrinter(printerId);
220     std::string printerId2 = "";
221     userData->SetLastUsedPrinter(printerId2);
222 }
223 
224 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0015, TestSize.Level1)
225 {
226     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
227     EXPECT_EQ(userData->GetDefaultPrinter(), "");
228 }
229 
230 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0016, TestSize.Level1)
231 {
232     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
233     userData->ParseUserData();
234 }
235 
236 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0017, TestSize.Level1)
237 {
238     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
239     std::string fileData = "";
240     userData->GetFileData(fileData);
241 }
242 
243 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0018, TestSize.Level1)
244 {
245     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
246     userData->SetUserDataToFile();
247 }
248 
249 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0019, TestSize.Level1)
250 {
251     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
252     EXPECT_EQ(userData->GetLastUsedPrinter(), "");
253 }
254 
255 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0020, TestSize.Level1)
256 {
257     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
258     std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-0105";
259     userData->SetDefaultPrinter(printerId, 0);
260     std::string printerId2 = "";
261     userData->SetDefaultPrinter(printerId2, 0);
262 }
263 
264 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0021, TestSize.Level1)
265 {
266     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
267     nlohmann::json jsonObject;
268     userData->ParseUserDataFromJson(jsonObject);
269     nlohmann::json userDataList;
270     jsonObject["print_user_data"] = userDataList;
271     userData->ParseUserDataFromJson(jsonObject);
272 
273     nlohmann::json jsonObject2;
274     nlohmann::json userDataList2;
275     userData->userId_ = 100;
276     nlohmann::json userData2 = nlohmann::json::array();
277     userDataList2["100"] = userData2;
278     jsonObject2["print_user_data"] = userDataList2;
279     userData->ParseUserDataFromJson(jsonObject2);
280 
281     nlohmann::json jsonObject3;
282     nlohmann::json userDataList3;
283     nlohmann::json userData3 = nlohmann::json::object();
284     userDataList3["100"] = userData3;
285     jsonObject3["print_user_data"] = userDataList3;
286     userData->ParseUserDataFromJson(jsonObject3);
287 }
288 
289 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0022, TestSize.Level1)
290 {
291     auto printUserData = std::make_shared<OHOS::Print::PrintUserData>();
292     nlohmann::json jsonObject;
293     nlohmann::json userDataList;
294     printUserData->userId_ = 100;
295     nlohmann::json userData = nlohmann::json::object();
296     userData["defaultPrinter"] = 123;
297     userDataList["100"] = userData;
298     jsonObject["print_user_data"] = userDataList;
299     printUserData->ParseUserDataFromJson(jsonObject);
300 
301     nlohmann::json jsonObject2;
302     nlohmann::json userDataList2;
303     nlohmann::json userData2 = nlohmann::json::object();
304     userData2["defaultPrinter"] = "123";
305     userDataList2["100"] = userData2;
306     jsonObject2["print_user_data"] = userDataList2;
307     printUserData->ParseUserDataFromJson(jsonObject2);
308 
309     nlohmann::json jsonObject3;
310     nlohmann::json userDataList3;
311     nlohmann::json userData3 = nlohmann::json::object();
312     userData3["defaultPrinter"] = "123";
313     userData3["lastUsedPrinter"] = 123;
314     userDataList3["100"] = userData3;
315     jsonObject3["print_user_data"] = userDataList3;
316     printUserData->ParseUserDataFromJson(jsonObject3);
317 
318     nlohmann::json jsonObject4;
319     nlohmann::json userDataList4;
320     nlohmann::json userData4 = nlohmann::json::object();
321     userData4["defaultPrinter"] = "123";
322     userData4["lastUsedPrinter"] = "123";
323     userDataList4["100"] = userData4;
324     jsonObject4["print_user_data"] = userDataList4;
325     printUserData->ParseUserDataFromJson(jsonObject4);
326 }
327 
328 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0023, TestSize.Level1)
329 {
330     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
331     nlohmann::json jsonObject;
332     std::string fileData0 = "test";
333     EXPECT_EQ(userData->CheckFileData(fileData0, jsonObject), false);
334 
335     nlohmann::json fileJson;
336     fileJson["key"] = "value";
337     std::string fileData = fileJson.dump();
338     EXPECT_EQ(userData->CheckFileData(fileData, jsonObject), false);
339 
340     nlohmann::json fileJson2;
341     fileJson2["version"] = 123;
342     std::string fileData2 = fileJson2.dump();
343     EXPECT_EQ(userData->CheckFileData(fileData2, jsonObject), false);
344 
345     nlohmann::json fileJson3;
346     fileJson3["version"] = "123";
347     std::string fileData3 = fileJson3.dump();
348     EXPECT_EQ(userData->CheckFileData(fileData3, jsonObject), false);
349 
350     nlohmann::json fileJson4;
351     fileJson4["version"] = "v1";
352     std::string fileData4 = fileJson4.dump();
353     EXPECT_EQ(userData->CheckFileData(fileData4, jsonObject), false);
354 
355     nlohmann::json fileJson5;
356     fileJson5["version"] = "v1";
357     fileJson5["print_user_data"] = "100";
358     std::string fileData5 = fileJson5.dump();
359     EXPECT_EQ(userData->CheckFileData(fileData5, jsonObject), true);
360 }
361 
362 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0030, TestSize.Level1)
363 {
364     std::string printerId1 = "com.ohos.spooler:p2p://DIRECT_PixLab_V1-0105";
365     std::string printerId2 = "com.ohos.spooler:p2p://DIRECT_PixLab_V1-0106";
366     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
367     EXPECT_NE(userData, nullptr);
368     userData->SetLastUsedPrinter(printerId1);
369     EXPECT_STREQ(userData->GetLastUsedPrinter().c_str(), printerId1.c_str());
370     userData->SetDefaultPrinter(printerId2, DEFAULT_PRINTER_TYPE_LAST_USED_PRINTER);
371     EXPECT_EQ(userData->CheckIfUseLastUsedPrinterForDefault(), true);
372     userData->SetLastUsedPrinter(printerId2);
373     userData->SetDefaultPrinter(printerId1, DELETE_DEFAULT_PRINTER);
374     userData->DeletePrinter(printerId1);
375     userData->DeletePrinter(printerId2);
376     userData->SetDefaultPrinter(printerId2, DELETE_LAST_USED_PRINTER);
377 }
378 }
379 }