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
18 #include "manage_auto_start_apps_serializer_test.h"
19 #include "edm_constants.h"
20 #include "utils.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace EDM {
26 namespace TEST {
SetUpTestSuite(void)27 void ManageAutoStartAppsSerializerTest::SetUpTestSuite(void)
28 {
29 Utils::SetEdmInitialEnv();
30 }
31
TearDownTestSuite(void)32 void ManageAutoStartAppsSerializerTest::TearDownTestSuite(void)
33 {
34 Utils::ResetTokenTypeAndUid();
35 ASSERT_TRUE(Utils::IsOriginalUTEnv());
36 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
37 }
38
39 /**
40 * @tc.name: TestSetDifferencePolicyDataEmpty
41 * @tc.desc: Test ManageAutoStartAppsSerializerTest::SetDifferencePolicy when data is empty
42 * @tc.type: FUNC
43 */
44 HWTEST_F(ManageAutoStartAppsSerializerTest, TestSetDifferencePolicyDataEmpty, TestSize.Level1)
45 {
46 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
47 std::vector<ManageAutoStartAppInfo> data;
48 std::vector<ManageAutoStartAppInfo> currentData;
49 std::vector<ManageAutoStartAppInfo> res = serializer->SetDifferencePolicyData(data, currentData);
50 ASSERT_TRUE(res.empty());
51 }
52
53 /**
54 * @tc.name: TestSerializeEmpty
55 * @tc.desc: Test ManageAutoStartAppsSerializerTest::Serialize when jsonString is empty
56 * @tc.type: FUNC
57 */
58 HWTEST_F(ManageAutoStartAppsSerializerTest, TestSerializeEmpty, TestSize.Level1)
59 {
60 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
61 std::string jsonString;
62 std::vector<ManageAutoStartAppInfo> dataObj;
63 bool ret = serializer->Serialize(dataObj, jsonString);
64 ASSERT_TRUE(ret);
65 ASSERT_TRUE(jsonString.empty());
66 }
67
68 /**
69 * @tc.name: TestSerializeSuc
70 * @tc.desc: Test ManageAutoStartAppsSerializerTest::Serialize
71 * @tc.type: FUNC
72 */
73 HWTEST_F(ManageAutoStartAppsSerializerTest, TestSerializeSuc, TestSize.Level1)
74 {
75 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
76 std::string jsonString;
77 std::vector<ManageAutoStartAppInfo> dataObj;
78 ManageAutoStartAppInfo info1;
79 info1.SetBundleName("test1");
80 info1.SetAbilityName("testAB1");
81 info1.SetDisallowModify(true);
82 dataObj.push_back(info1);
83 bool ret = serializer->Serialize(dataObj, jsonString);
84 ASSERT_TRUE(ret);
85 ASSERT_FALSE(jsonString.empty());
86 }
87
88 /**
89 * @tc.name: TestDeserializeWithEmptyString
90 * @tc.desc: Test ManageAutoStartAppsSerializerTest::Deserialize jsonString is empty
91 * @tc.type: FUNC
92 */
93 HWTEST_F(ManageAutoStartAppsSerializerTest, TestDeserializeWithEmptyString, TestSize.Level1)
94 {
95 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
96 std::string jsonString = "";
97 std::vector<ManageAutoStartAppInfo> dataObj;
98 bool ret = serializer->Deserialize(jsonString, dataObj);
99 ASSERT_TRUE(ret);
100 }
101
102 /**
103 * @tc.name: TestDeserializeWithJustBundleNameAndAbilityName
104 * @tc.desc: Test ManageAutoStartAppsSerializerTest::Deserialize WithJustBundleNameAndAbilityName
105 * @tc.type: FUNC
106 */
107 HWTEST_F(ManageAutoStartAppsSerializerTest, TestDeserializeWithJustBundleNameAndAbilityName, TestSize.Level1)
108 {
109 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
110 std::string jsonString = R"(["test1/testAB1"])";
111 std::vector<ManageAutoStartAppInfo> dataObj;
112 bool ret = serializer->Deserialize(jsonString, dataObj);
113 ASSERT_TRUE(ret);
114 ASSERT_TRUE(dataObj.size() == 1);
115 ASSERT_TRUE(dataObj[0].GetBundleName() == "test1");
116 ASSERT_TRUE(dataObj[0].GetAbilityName() == "testAB1");
117 ASSERT_TRUE(dataObj[0].GetAbilityName() == "testAB1");
118 ASSERT_TRUE(dataObj[0].GetUniqueKey() == "test1/testAB1");
119 ASSERT_TRUE(dataObj[0].GetDisallowModify());
120 }
121
122 /**
123 * @tc.name: TestDeserializeSuc
124 * @tc.desc: Test ManageAutoStartAppsSerializerTest::Deserialize
125 * @tc.type: FUNC
126 */
127 HWTEST_F(ManageAutoStartAppsSerializerTest, TestDeserializeSuc, TestSize.Level1)
128 {
129 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
130 std::string jsonString = R"([{"bundleName": "test", "abilityName": "testAB", "disallowModify": false}])";
131 std::vector<ManageAutoStartAppInfo> dataObj;
132 bool ret = serializer->Deserialize(jsonString, dataObj);
133 ASSERT_TRUE(ret);
134 ASSERT_EQ(dataObj.size(), 1);
135 ASSERT_EQ(dataObj[0].GetBundleName(), "test");
136 ASSERT_EQ(dataObj[0].GetAbilityName(), "testAB");
137 ASSERT_EQ(dataObj[0].GetDisallowModify(), false);
138 }
139
140 /**
141 * @tc.name: TestDeserializeMalformedJson
142 * @tc.desc: Test ManageAutoStartAppsSerializerTest::Deserialize MalformedJson
143 * @tc.type: FUNC
144 */
145 HWTEST_F(ManageAutoStartAppsSerializerTest, TestDeserializeMalformedJson, TestSize.Level1)
146 {
147 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
148 std::string jsonString = R"([
149 {"bundleName": "test1", "abilityName": "testAB1", "disallowModify": false,
150 {"bundleName": "test2", "abilityName": "testAB2", "disallowModify": true}
151 ])";
152 std::vector<ManageAutoStartAppInfo> dataObj;
153 serializer->Deserialize(jsonString, dataObj);
154 ASSERT_TRUE(dataObj.empty());
155 }
156
157 /**
158 * @tc.name: TestGetPolicyOutOfRange
159 * @tc.desc: Test ManageAutoStartAppsSerializerTest::GetPolicy out of range
160 * @tc.type: FUNC
161 */
162 HWTEST_F(ManageAutoStartAppsSerializerTest, TestGetPolicyOutOfRange, TestSize.Level1)
163 {
164 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
165 MessageParcel data;
166 data.WriteInt32(EdmConstants::AUTO_START_APPS_MAX_SIZE + 1);
167 std::vector<ManageAutoStartAppInfo> dataObj;
168 bool ret = serializer->GetPolicy(data, dataObj);
169 ASSERT_FALSE(ret);
170 }
171
172 /**
173 * @tc.name: TestGetPolicy
174 * @tc.desc: Test ManageAutoStartAppsSerializerTest::GetPolicy
175 * @tc.type: FUNC
176 */
177 HWTEST_F(ManageAutoStartAppsSerializerTest, TestGetPolicy, TestSize.Level1)
178 {
179 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
180 MessageParcel data;
181 std::vector<ManageAutoStartAppInfo> dataObj;
182 data.WriteInt32(1);
183 data.WriteString("test1");
184 data.WriteString("testAB1");
185 data.WriteBool(true);
186 bool ret = serializer->GetPolicy(data, dataObj);
187 ASSERT_TRUE(ret);
188 ASSERT_TRUE(dataObj[0].GetBundleName() == "test1");
189 ASSERT_TRUE(dataObj[0].GetAbilityName() == "testAB1");
190 ASSERT_TRUE(dataObj[0].GetDisallowModify());
191 }
192
193 /**
194 * @tc.name: TestWritePolicy
195 * @tc.desc: Test ManageAutoStartAppsSerializerTest::WritePolicy
196 * @tc.type: FUNC
197 */
198 HWTEST_F(ManageAutoStartAppsSerializerTest, TestWritePolicy, TestSize.Level1)
199 {
200 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
201 MessageParcel reply;
202 std::vector<ManageAutoStartAppInfo> dataObj;
203 bool ret = serializer->WritePolicy(reply, dataObj);
204 ASSERT_TRUE(ret);
205 }
206
207 /**
208 * @tc.name: TestMergePolicy
209 * @tc.desc: Test ManageAutoStartAppsSerializerTest::MergePolicy
210 * @tc.type: FUNC
211 */
212 HWTEST_F(ManageAutoStartAppsSerializerTest, TestMergePolicy, TestSize.Level1)
213 {
214 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
215 std::vector<std::vector<ManageAutoStartAppInfo>> dataObj;
216 std::vector<ManageAutoStartAppInfo> data;
217 ManageAutoStartAppInfo id1;
218 id1.SetBundleName("test1");
219 id1.SetAbilityName("testAB1");
220 id1.SetDisallowModify(true);
221 data.push_back(id1);
222 dataObj.push_back(data);
223
224 std::vector<ManageAutoStartAppInfo> data2;
225 ManageAutoStartAppInfo id2;
226 id2.SetUniqueKey("test1/testAB1");
227 id2.SetDisallowModify(false);
228 data2.push_back(id2);
229 dataObj.push_back(data2);
230 std::vector<ManageAutoStartAppInfo> result;
231 serializer->MergePolicy(dataObj, result);
232 ASSERT_TRUE(result.size() == 1);
233 ASSERT_TRUE(result[0].GetDisallowModify());
234 }
235
236 /**
237 * @tc.name: TestUpdateByMergePolicy
238 * @tc.desc: Test ManageAutoStartAppsSerializerTest::UpdateByMergePolicy
239 * @tc.type: FUNC
240 */
241 HWTEST_F(ManageAutoStartAppsSerializerTest, TestUpdateByMergePolicy, TestSize.Level1)
242 {
243 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
244 std::vector<ManageAutoStartAppInfo> data;
245 ManageAutoStartAppInfo id1;
246 id1.SetBundleName("test1");
247 id1.SetAbilityName("testAB1");
248 id1.SetDisallowModify(true);
249 data.push_back(id1);
250
251 ManageAutoStartAppInfo id2;
252 id2.SetBundleName("test2");
253 id2.SetAbilityName("testAB2");
254 id2.SetDisallowModify(true);
255 data.push_back(id2);
256
257 std::vector<ManageAutoStartAppInfo> data2;
258 ManageAutoStartAppInfo id3;
259 id3.SetBundleName("test2");
260 id3.SetAbilityName("testAB2");
261 id3.SetDisallowModify(false);
262 data2.push_back(id3);
263
264 ManageAutoStartAppInfo id4;
265 id4.SetBundleName("test3");
266 id4.SetAbilityName("testAB4");
267 id4.SetDisallowModify(false);
268 data2.push_back(id3);
269
270 ManageAutoStartAppInfo id5;
271 id5.SetBundleName("test4");
272 id5.SetAbilityName("testAB4");
273 id5.SetDisallowModify(false);
274 data2.push_back(id5);
275
276 serializer->UpdateByMergePolicy(data, data2);
277 ASSERT_TRUE(data.size() == 2);
278 ASSERT_FALSE(data[1].GetDisallowModify());
279 }
280
281 /**
282 * @tc.name: TestSetIntersectionPolicyData
283 * @tc.desc: Test ManageAutoStartAppsSerializerTest::SetIntersectionPolicyData
284 * @tc.type: FUNC
285 */
286 HWTEST_F(ManageAutoStartAppsSerializerTest, TestSetIntersectionPolicyData, TestSize.Level1)
287 {
288 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
289 std::vector<std::string> uniqueKey;
290 uniqueKey.push_back("test1/testAB1");
291 uniqueKey.push_back("test2/testAB2");
292
293 std::vector<ManageAutoStartAppInfo> data;
294 ManageAutoStartAppInfo id1;
295 id1.SetUniqueKey("test1/testAB1");
296 id1.SetDisallowModify(true);
297 data.push_back(id1);
298
299 ManageAutoStartAppInfo id2;
300 id2.SetUniqueKey("test3/testAB3");
301 id2.SetDisallowModify(true);
302 data.push_back(id2);
303
304 std::vector<ManageAutoStartAppInfo>result = serializer->SetIntersectionPolicyData(uniqueKey, data);
305 ASSERT_TRUE(result.size() == 1);
306 ASSERT_TRUE(result[0].GetBundleName() == "test1");
307 }
308
309 /**
310 * @tc.name: TestSetNeedRemoveMergePolicyData
311 * @tc.desc: Test ManageAutoStartAppsSerializerTest::SetNeedRemoveMergePolicyData
312 * @tc.type: FUNC
313 */
314 HWTEST_F(ManageAutoStartAppsSerializerTest, TestSetNeedRemoveMergePolicyData, TestSize.Level1)
315 {
316 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
317 std::vector<ManageAutoStartAppInfo> data;
318 ManageAutoStartAppInfo id1;
319 id1.SetUniqueKey("test1/testAB1");
320 id1.SetDisallowModify(true);
321 data.push_back(id1);
322
323 ManageAutoStartAppInfo id2;
324 id2.SetUniqueKey("test2/testAB2");
325 id2.SetDisallowModify(true);
326 data.push_back(id2);
327
328 std::vector<ManageAutoStartAppInfo> mergeData;
329 ManageAutoStartAppInfo id3;
330 id3.SetUniqueKey("test1/testAB1");
331 id3.SetDisallowModify(true);
332 mergeData.push_back(id3);
333
334 ManageAutoStartAppInfo id4;
335 id4.SetUniqueKey("test3/testAB3");
336 id4.SetDisallowModify(true);
337 mergeData.push_back(id4);
338
339 ManageAutoStartAppInfo id5;
340 id5.SetUniqueKey("test4/testAB4");
341 id5.SetDisallowModify(true);
342 mergeData.push_back(id5);
343
344 std::vector<ManageAutoStartAppInfo>result = serializer->SetNeedRemoveMergePolicyData(mergeData, data);
345 ASSERT_TRUE(result.size() == 1);
346 ASSERT_TRUE(result[0].GetBundleName() == "test2");
347 }
348
349 /**
350 * @tc.name: TestSetUnionPolicyData
351 * @tc.desc: Test ManageAutoStartAppsSerializerTest::SetUnionPolicyData
352 * @tc.type: FUNC
353 */
354 HWTEST_F(ManageAutoStartAppsSerializerTest, TestSetUnionPolicyData, TestSize.Level1)
355 {
356 auto serializer = ManageAutoStartAppsSerializer::GetInstance();
357 std::vector<ManageAutoStartAppInfo> data;
358 ManageAutoStartAppInfo id1;
359 id1.SetUniqueKey("test1/testAB1");
360 id1.SetDisallowModify(true);
361 data.push_back(id1);
362
363 ManageAutoStartAppInfo id2;
364 id2.SetUniqueKey("test2/testAB2");
365 id2.SetDisallowModify(true);
366 data.push_back(id2);
367
368 std::vector<ManageAutoStartAppInfo> mergeData;
369 ManageAutoStartAppInfo id3;
370 id3.SetUniqueKey("test1/testAB1");
371 id3.SetDisallowModify(false);
372 mergeData.push_back(id3);
373
374 ManageAutoStartAppInfo id4;
375 id4.SetUniqueKey("test3/testAB3");
376 id4.SetDisallowModify(true);
377 mergeData.push_back(id4);
378
379 ManageAutoStartAppInfo id5;
380 id5.SetUniqueKey("test4/testAB4");
381 id5.SetDisallowModify(true);
382 mergeData.push_back(id5);
383
384 std::vector<ManageAutoStartAppInfo>result = serializer->SetUnionPolicyData(data, mergeData);
385 ASSERT_TRUE(result.size() == 4);
386 ASSERT_TRUE(result[0].GetBundleName() == "test1");
387 ASSERT_FALSE(result[0].GetDisallowModify());
388 }
389 } // namespace TEST
390 } // namespace EDM
391 } // namespace OHOS