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 #include "gtest/gtest.h"
16 #include "mock_constant.h"
17 #define private public
18 #define protected public
19 #include "ability_filter.h"
20 #include "deferred_link_mgr.h"
21 #undef private
22 #undef protected
23 #include "mock_ability_filter.h"
24 namespace OHOS::AppDomainVerify {
25 using namespace testing;
26 using namespace testing::ext;
27 constexpr const char* BUNDLE_NAME_WRONG = "BUNDLE_NAME_WRONG";
28 constexpr const char* BUNDLE_DOMAIN = "https://www.openharmony.cn";
29 constexpr const char* BUNDLE_DOMAIN_WRONG = "https://www.openharmony_wrong.cn";
30 constexpr const char* BUNDLE_URL = "https://www.openharmony.cn/100";
31 constexpr const char* BUNDLE_URL_NEW = "https://www.openharmony.cn/new";
32 constexpr const char* TASK_ID = "age";
33 constexpr int MAX_CACHE_SIZE = 50;
34 class DeferredLinkMgrTest : 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 DeferredLinkMgrTest::SetUpTestCase(void)
43 {
44 }
45
TearDownTestCase(void)46 void DeferredLinkMgrTest::TearDownTestCase(void)
47 {
48 }
49
SetUp(void)50 void DeferredLinkMgrTest::SetUp(void)
51 {
52 }
53
TearDown(void)54 void DeferredLinkMgrTest::TearDown(void)
55 {
56 }
57
58 /**
59 * @tc.name: DeferredLinkPutTest001
60 * @tc.desc: put one link, remain one.
61 * @tc.type: FUNC
62 */
63 HWTEST_F(DeferredLinkMgrTest, DeferredLinkPutTest001, TestSize.Level0)
64 {
65 DeferredLinkMgr deferredLinkMgr;
66 deferredLinkMgr.ageHandler_ = nullptr;
67
68 deferredLinkMgr.PutDeferredLink(
69 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
70
71 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
72 EXPECT_TRUE(deferredLinkMgr.caches_.front().domain == BUNDLE_DOMAIN);
73 EXPECT_TRUE(deferredLinkMgr.caches_.front().url == BUNDLE_URL);
74 }
75
76 /**
77 * @tc.name: DeferredLinkPutTest002
78 * @tc.desc: put max_size + 1 link, will remain maxsize.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(DeferredLinkMgrTest, DeferredLinkPutTest002, TestSize.Level0)
82 {
83 DeferredLinkMgr deferredLinkMgr;
84 deferredLinkMgr.ageHandler_ = nullptr;
85
86 for (int i = 0; i < MAX_CACHE_SIZE + 1; i++) {
87 deferredLinkMgr.PutDeferredLink({ .domain = BUNDLE_DOMAIN + std::to_string(i),
88 .url = BUNDLE_URL,
89 .timeStamp = GetSecondsSince1970ToNow() });
90 }
91
92 EXPECT_TRUE(deferredLinkMgr.caches_.size() == MAX_CACHE_SIZE);
93 EXPECT_EQ(deferredLinkMgr.caches_.back().domain, BUNDLE_DOMAIN + std::to_string(1));
94 EXPECT_EQ(deferredLinkMgr.caches_.front().domain, BUNDLE_DOMAIN + std::to_string(MAX_CACHE_SIZE));
95 }
96
97 /**
98 * @tc.name: DeferredLinkPutTest003
99 * @tc.desc: put duplicate link, will unique and in back.
100 * @tc.type: FUNC
101 */
102 HWTEST_F(DeferredLinkMgrTest, DeferredLinkPutTest003, TestSize.Level0)
103 {
104 DeferredLinkMgr deferredLinkMgr;
105 deferredLinkMgr.ageHandler_ = nullptr;
106
107 deferredLinkMgr.PutDeferredLink(
108 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
109 deferredLinkMgr.PutDeferredLink(
110 { .domain = BUNDLE_DOMAIN + std::to_string(1), .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
111 deferredLinkMgr.PutDeferredLink(
112 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
113
114 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 2);
115 EXPECT_EQ(deferredLinkMgr.caches_.back().domain, BUNDLE_DOMAIN + std::to_string(1));
116 EXPECT_EQ(deferredLinkMgr.caches_.front().domain, BUNDLE_DOMAIN);
117 }
118
119 /**
120 * @tc.name: DeferredLinkGetTest001
121 * @tc.desc: get link with matched domain and matched url, return link.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest001, TestSize.Level0)
125 {
126 DeferredLinkMgr deferredLinkMgr;
127 deferredLinkMgr.ageHandler_ = nullptr;
128 std::shared_ptr<MocAbilityFilter> filter = std::make_shared<MocAbilityFilter>();
129 EXPECT_CALL(*filter, Filter(_)).Times(1).WillOnce(Return(true));
130 MockAbilityFilter(filter);
131 deferredLinkMgr.PutDeferredLink(
132 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
133 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
134
135 std::vector<std::string> domains;
136 domains.emplace_back(BUNDLE_DOMAIN);
137 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
138
139 EXPECT_FALSE(link.empty());
140 EXPECT_EQ(link, BUNDLE_URL);
141 EXPECT_TRUE(deferredLinkMgr.caches_.empty());
142
143 auto link1 = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
144 EXPECT_TRUE(link1.empty());
145 }
146
147 /**
148 * @tc.name: DeferredLinkGetTest002
149 * @tc.desc: get link with unmatched domains and matched bundleName, return none.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest002, TestSize.Level0)
153 {
154 DeferredLinkMgr deferredLinkMgr;
155 deferredLinkMgr.ageHandler_ = nullptr;
156 std::shared_ptr<MocAbilityFilter> filter = std::make_shared<MocAbilityFilter>();
157 EXPECT_CALL(*filter, Filter(_)).Times(0);
158 MockAbilityFilter(filter);
159 deferredLinkMgr.PutDeferredLink(
160 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
161 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
162
163 std::vector<std::string> domains;
164 domains.emplace_back(BUNDLE_DOMAIN_WRONG);
165 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
166
167 EXPECT_TRUE(link.empty());
168 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
169 }
170
171 /**
172 * @tc.name: DeferredLinkGetTest003
173 * @tc.desc: get link with unmatched domains and matched bundleName, return none.
174 * @tc.type: FUNC
175 */
176 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest003, TestSize.Level0)
177 {
178 DeferredLinkMgr deferredLinkMgr;
179 deferredLinkMgr.ageHandler_ = nullptr;
180 std::shared_ptr<MocAbilityFilter> filter = std::make_shared<MocAbilityFilter>();
181 EXPECT_CALL(*filter, Filter(_)).Times(0);
182 MockAbilityFilter(filter);
183 deferredLinkMgr.PutDeferredLink(
184 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
185 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
186
187 std::vector<std::string> domains;
188 domains.emplace_back(BUNDLE_DOMAIN_WRONG);
189 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
190
191 EXPECT_TRUE(link.empty());
192 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
193 }
194
195 /**
196 * @tc.name: DeferredLinkGetTest004
197 * @tc.desc: get link with unmatched bundleName and matched domains, return none.
198 * @tc.type: FUNC
199 */
200 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest004, TestSize.Level0)
201 {
202 DeferredLinkMgr deferredLinkMgr;
203 deferredLinkMgr.ageHandler_ = nullptr;
204 std::shared_ptr<MocAbilityFilter> filter = std::make_shared<MocAbilityFilter>();
205 EXPECT_CALL(*filter, Filter(_)).Times(1).WillOnce(Return(false));
206 MockAbilityFilter(filter);
207 deferredLinkMgr.PutDeferredLink(
208 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
209 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
210
211 std::vector<std::string> domains;
212 domains.emplace_back(BUNDLE_DOMAIN);
213 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME_WRONG, domains);
214
215 EXPECT_TRUE(link.empty());
216 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
217 }
218
219 /**
220 * @tc.name: DeferredLinkGetTest005
221 * @tc.desc: get link with matched domain and matched url, return new link, cache remove link all.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest005, TestSize.Level0)
225 {
226 DeferredLinkMgr deferredLinkMgr;
227 deferredLinkMgr.ageHandler_ = nullptr;
228 std::shared_ptr<MocAbilityFilter> filter = std::make_shared<MocAbilityFilter>();
229 EXPECT_CALL(*filter, Filter(_)).Times(2).WillRepeatedly(Return(true));
230 MockAbilityFilter(filter);
231 deferredLinkMgr.PutDeferredLink(
232 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
233 deferredLinkMgr.PutDeferredLink(
234 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL_NEW, .timeStamp = GetSecondsSince1970ToNow() });
235 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 2);
236
237 std::vector<std::string> domains;
238 domains.emplace_back(BUNDLE_DOMAIN);
239 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
240
241 EXPECT_FALSE(link.empty());
242 EXPECT_EQ(link, BUNDLE_URL_NEW);
243 EXPECT_TRUE(deferredLinkMgr.caches_.empty());
244
245 auto link1 = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
246 EXPECT_TRUE(link1.empty());
247 }
248
249 /**
250 * @tc.name: DeferredLinkGetTest006
251 * @tc.desc: get link from empty cache, return null.
252 * @tc.type: FUNC
253 */
254 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest006, TestSize.Level0)
255 {
256 DeferredLinkMgr deferredLinkMgr;
257 deferredLinkMgr.ageHandler_ = nullptr;
258 std::shared_ptr<MocAbilityFilter> filter = std::make_shared<MocAbilityFilter>();
259 MockAbilityFilter(filter);
260
261 std::vector<std::string> domains;
262 domains.emplace_back(BUNDLE_DOMAIN);
263 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
264
265 EXPECT_TRUE(link.empty());
266 }
267 /**
268 * @tc.name: DeferredLinkGetTest007
269 * @tc.desc: age process.
270 * @tc.type: FUNC
271 */
272 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest007, TestSize.Level0)
273 {
274 DeferredLinkMgr deferredLinkMgr;
275 deferredLinkMgr.ageHandler_ = nullptr;
276 deferredLinkMgr.PutDeferredLink(
277 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() - 10 * 60 });
278 deferredLinkMgr.AgeCacheProcess();
279 ASSERT_TRUE(deferredLinkMgr.caches_.empty());
280 }
281 /**
282 * @tc.name: DeferredLinkGetTest008
283 * @tc.desc: age process.
284 * @tc.type: FUNC
285 */
286 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest008, TestSize.Level0)
287 {
288 DeferredLinkMgr deferredLinkMgr;
289 deferredLinkMgr.ageHandler_ = nullptr;
290 deferredLinkMgr.PutDeferredLink(
291 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
292 deferredLinkMgr.AgeCacheProcess();
293 ASSERT_FALSE(deferredLinkMgr.caches_.empty());
294 }
295 /**
296 * @tc.name: DeferredLinkGetTest009
297 * @tc.desc: remove deferred link, so get empty link.
298 * @tc.type: FUNC
299 */
300 HWTEST_F(DeferredLinkMgrTest, DeferredLinkGetTest009, TestSize.Level0)
301 {
302 DeferredLinkMgr deferredLinkMgr;
303 deferredLinkMgr.ageHandler_ = nullptr;
304 deferredLinkMgr.PutDeferredLink(
305 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
306 EXPECT_TRUE(deferredLinkMgr.caches_.size() == 1);
307
308 deferredLinkMgr.RemoveDeferredLink(
309 { .domain = BUNDLE_DOMAIN, .url = BUNDLE_URL, .timeStamp = GetSecondsSince1970ToNow() });
310 EXPECT_TRUE(deferredLinkMgr.caches_.empty());
311
312 std::vector<std::string> domains;
313 domains.emplace_back(BUNDLE_DOMAIN);
314 auto link = deferredLinkMgr.GetDeferredLink(BUNDLE_NAME, domains);
315
316 EXPECT_TRUE(link.empty());
317 }
318 }