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 #define private public
18 #include "distributed_local_config.h"
19 #include "distributed_service.h"
20 #include "distributed_subscriber.h"
21 #undef private
22 #include "notification_request.h"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Notification {
28 class DistribuedSubscriberTest : public testing::Test {
29 public:
30 void SetUp() override;
31 void TearDown() override;
32
33 private:
34 std::unordered_set<std::string> collaborativeDeleteTypes_;
35 };
36
SetUp()37 void DistribuedSubscriberTest::SetUp()
38 {
39 collaborativeDeleteTypes_ = DistributedLocalConfig::GetInstance().GetCollaborativeDeleteTypes();
40 std::unordered_set<std::string> collaborativeDeleteTypes({ "LIVE_VIEW" });
41 DistributedLocalConfig::GetInstance().localConfig_.collaborativeDeleteTypes = collaborativeDeleteTypes;
42 }
43
TearDown()44 void DistribuedSubscriberTest::TearDown()
45 {
46 DistributedLocalConfig::GetInstance().localConfig_.collaborativeDeleteTypes = collaborativeDeleteTypes_;
47 }
48
49 /**
50 * @tc.name : DistribuedSubscriberTest_00100
51 * @tc.number : DistribuedSubscriberTest_00100
52 * @tc.desc : Test the CheckNeedCollaboration function with null notification.
53 */
54 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00100, Function | SmallTest | Level1)
55 {
56 std::shared_ptr<Notification> notification = nullptr;
57 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
58 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
59 }
60
61 /**
62 * @tc.name : DistribuedSubscriberTest_00200
63 * @tc.number : DistribuedSubscriberTest_00200
64 * @tc.desc : Test the CheckNeedCollaboration function with null SlotType.
65 */
66 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00200, Function | SmallTest | Level1)
67 {
68 sptr<NotificationRequest> request = new NotificationRequest(1);
69 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
70 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
71 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
72 }
73
74 /**
75 * @tc.name : DistribuedSubscriberTest_00300
76 * @tc.number : DistribuedSubscriberTest_00300
77 * @tc.desc : Test the CheckNeedCollaboration function with SlotType SOCIAL_COMMUNICATION.
78 */
79 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00300, Function | SmallTest | Level1)
80 {
81 sptr<NotificationRequest> request = new NotificationRequest(1);
82 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
83 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
84 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
85 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
86 }
87
88 /**
89 * @tc.name : DistribuedSubscriberTest_00400
90 * @tc.number : DistribuedSubscriberTest_00400
91 * @tc.desc : Test the CheckNeedCollaboration function with SlotType SERVICE_REMINDER.
92 */
93 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00400, Function | SmallTest | Level1)
94 {
95 sptr<NotificationRequest> request = new NotificationRequest(1);
96 request->SetSlotType(NotificationConstant::SlotType::SERVICE_REMINDER);
97 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
98 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
99 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
100 }
101
102 /**
103 * @tc.name : DistribuedSubscriberTest_00500
104 * @tc.number : DistribuedSubscriberTest_00500
105 * @tc.desc : Test the CheckNeedCollaboration function with SlotType CONTENT_INFORMATION.
106 */
107 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00500, Function | SmallTest | Level1)
108 {
109 sptr<NotificationRequest> request = new NotificationRequest(1);
110 request->SetSlotType(NotificationConstant::SlotType::CONTENT_INFORMATION);
111 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
112 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
113 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
114 }
115
116 /**
117 * @tc.name : DistribuedSubscriberTest_00600
118 * @tc.number : DistribuedSubscriberTest_00600
119 * @tc.desc : Test the CheckNeedCollaboration function with SlotType OTHER.
120 */
121 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00600, Function | SmallTest | Level1)
122 {
123 sptr<NotificationRequest> request = new NotificationRequest(1);
124 request->SetSlotType(NotificationConstant::SlotType::OTHER);
125 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
126 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
127 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
128 }
129
130 /**
131 * @tc.name : DistribuedSubscriberTest_00700
132 * @tc.number : DistribuedSubscriberTest_00700
133 * @tc.desc : Test the CheckNeedCollaboration function with SlotType CUSTOM.
134 */
135 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00700, Function | SmallTest | Level1)
136 {
137 sptr<NotificationRequest> request = new NotificationRequest(1);
138 request->SetSlotType(NotificationConstant::SlotType::CUSTOM);
139 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
140 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
141 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
142 }
143
144 /**
145 * @tc.name : DistribuedSubscriberTest_00800
146 * @tc.number : DistribuedSubscriberTest_00800
147 * @tc.desc : Test the CheckNeedCollaboration function with SlotType LIVE_VIEW.
148 */
149 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00800, Function | SmallTest | Level1)
150 {
151 sptr<NotificationRequest> request = new NotificationRequest(1);
152 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
153 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
154 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
155 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), true);
156 }
157
158 /**
159 * @tc.name : DistribuedSubscriberTest_00900
160 * @tc.number : DistribuedSubscriberTest_00900
161 * @tc.desc : Test the CheckNeedCollaboration function with SlotType CUSTOMER_SERVICE.
162 */
163 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00900, Function | SmallTest | Level1)
164 {
165 sptr<NotificationRequest> request = new NotificationRequest(1);
166 request->SetSlotType(NotificationConstant::SlotType::CUSTOMER_SERVICE);
167 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
168 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
169 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
170 }
171
172 /**
173 * @tc.name : DistribuedSubscriberTest_01000
174 * @tc.number : DistribuedSubscriberTest_01000
175 * @tc.desc : Test the CheckNeedCollaboration function with SlotType EMERGENCY_INFORMATION.
176 */
177 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01000, Function | SmallTest | Level1)
178 {
179 sptr<NotificationRequest> request = new NotificationRequest(1);
180 request->SetSlotType(NotificationConstant::SlotType::EMERGENCY_INFORMATION);
181 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
182 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
183 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
184 }
185
186 /**
187 * @tc.name : DistribuedSubscriberTest_01100
188 * @tc.number : DistribuedSubscriberTest_01100
189 * @tc.desc : Test the CheckNeedCollaboration function with SlotType ILLEGAL_TYPE.
190 */
191 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01100, Function | SmallTest | Level1)
192 {
193 sptr<NotificationRequest> request = new NotificationRequest(1);
194 request->SetSlotType(NotificationConstant::SlotType::ILLEGAL_TYPE);
195 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
196 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
197 EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false);
198 }
199
200 /**
201 * @tc.name : DistribuedSubscriberTest_01200
202 * @tc.number : DistribuedSubscriberTest_01200
203 * @tc.desc : Test the OnBatchCanceled function with deleteReason DEFAULT_REASON_DELETE.
204 */
205 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01200, Function | SmallTest | Level1)
206 {
207 std::vector<std::shared_ptr<Notification>> requestList;
208 std::shared_ptr<NotificationSortingMap> sortingMap;
209 int32_t deleteReason = 0;
210
211 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
212 subscriber->OnBatchCanceled(requestList, sortingMap, deleteReason);
213 EXPECT_EQ(deleteReason == NotificationConstant::DISTRIBUTED_COLLABORATIVE_DELETE, false);
214 }
215
216 /**
217 * @tc.name : DistribuedSubscriberTest_01300
218 * @tc.number : DistribuedSubscriberTest_01300
219 * @tc.desc : Test the OnBatchCanceled function with deleteReason LIVE_VIEW.
220 */
221 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01300, Function | SmallTest | Level1)
222 {
223 sptr<NotificationRequest> request = new NotificationRequest(1);
224 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
225 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
226
227 std::vector<std::shared_ptr<Notification>> requestList;
228 requestList.push_back(notification);
229 std::shared_ptr<NotificationSortingMap> sortingMap;
230 int32_t deleteReason = 32;
231 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
232 subscriber->OnBatchCanceled(requestList, sortingMap, deleteReason);
233 EXPECT_NE(requestList.size(), 0);
234 }
235
236 /**
237 * @tc.name : DistribuedSubscriberTest_01400
238 * @tc.number : DistribuedSubscriberTest_01400
239 * @tc.desc : Test the OnCanceled function with deleteReason DEFAULT_REASON_DELETE.
240 */
241 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01400, Function | SmallTest | Level1)
242 {
243 sptr<NotificationRequest> request = new NotificationRequest(1);
244 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
245 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
246 std::shared_ptr<NotificationSortingMap> sortingMap;
247 int32_t deleteReason = 0;
248 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
249 subscriber->OnCanceled(notification, sortingMap, deleteReason);
250 EXPECT_EQ(deleteReason, 0);
251 }
252
253 /**
254 * @tc.name : DistribuedSubscriberTest_01500
255 * @tc.number : DistribuedSubscriberTest_01500
256 * @tc.desc : Test the OnCanceled function with deleteReason LIVE_VIEW.
257 */
258 HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01500, Function | SmallTest | Level1)
259 {
260 sptr<NotificationRequest> request = new NotificationRequest(1);
261 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
262 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
263 std::shared_ptr<NotificationSortingMap> sortingMap;
264 int32_t deleteReason = 32;
265
266 std::shared_ptr<DistribuedSubscriber> subscriber = std::make_shared<DistribuedSubscriber>();
267 subscriber->OnCanceled(notification, sortingMap, deleteReason);
268 EXPECT_EQ(deleteReason, 32);
269 }
270 } // namespace Notification
271 } // namespace OHOS