1 /*
2 * Copyright (c) 2022 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 <gmock/gmock.h>
18
19 #define private public
20 #define protected public
21
22 #include "ability_manager_errors.h"
23 #include "connection_data.h"
24 #include "connection_observer_client.h"
25 #include "connection_observer_client_impl.h"
26 #include "connection_observer_stub_impl.h"
27 #ifdef WITH_DLP
28 #include "dlp_state_data.h"
29 #endif // WITH_DLP
30 #include "hilog_tag_wrapper.h"
31 #include "mock_native_token.h"
32 #include "parcel.h"
33
34 using namespace testing::ext;
35 using namespace testing;
36
37 namespace OHOS {
38 namespace AbilityRuntime {
39 namespace {
40 const int32_t TEST_PID = 10001;
41 const int32_t TEST_UID = 10002;
42 const std::string TEST_BUNDLE_NAME = "com.ohos.connnection.test";
43 const std::string TEST_MODULE_NAME = "entry";
44 const std::string TEST_ABILITY_NAME = "TestServiceExtension";
45 const int32_t TEST_CALLER_PID = 10003;
46 const int32_t TEST_CALLER_UID = 10004;
47 const std::string TEST_CALLER_NAME = "test_caller";
48
49 class MyConnectionObserver : public ConnectionObserver {
50 public:
MyConnectionObserver()51 MyConnectionObserver() {}
~MyConnectionObserver()52 ~MyConnectionObserver() {}
53
OnExtensionConnected(const ConnectionData & data)54 void OnExtensionConnected(const ConnectionData& data)
55 {
56 isExtensionConnected_ = true;
57 }
58
OnExtensionDisconnected(const ConnectionData & data)59 void OnExtensionDisconnected(const ConnectionData& data)
60 {
61 isExtensionDisconnected_ = true;
62 }
63
OnExtensionSuspended(const ConnectionData & data)64 void OnExtensionSuspended(const ConnectionData& data)
65 {
66 isExtensionSuspended_ = true;
67 }
68
OnExtensionResumed(const ConnectionData & data)69 void OnExtensionResumed(const ConnectionData& data)
70 {
71 isExtensionResumed_ = true;
72 }
73
OnDlpAbilityOpened(const DlpStateData & data)74 void OnDlpAbilityOpened(const DlpStateData& data)
75 {
76 isDlpAbilityOpened_ = true;
77 }
78
OnDlpAbilityClosed(const DlpStateData & data)79 void OnDlpAbilityClosed(const DlpStateData& data)
80 {
81 isDlpAbilityClosed_ = true;
82 }
83
OnServiceDied()84 void OnServiceDied()
85 {
86 isServiceDied_ = true;
87 }
88
IsExtensionConnected() const89 bool IsExtensionConnected() const
90 {
91 return isExtensionConnected_;
92 }
93
IsExtensionDisconnected() const94 bool IsExtensionDisconnected() const
95 {
96 return isExtensionDisconnected_;
97 }
98
IsDlpAbilityOpened() const99 bool IsDlpAbilityOpened() const
100 {
101 return isDlpAbilityOpened_;
102 }
103
IsDlpAbilityClosed() const104 bool IsDlpAbilityClosed() const
105 {
106 return isDlpAbilityClosed_;
107 }
108
IsServiceDied() const109 bool IsServiceDied() const
110 {
111 return isServiceDied_;
112 }
113
IsExtensionSuspended() const114 bool IsExtensionSuspended() const
115 {
116 return isExtensionSuspended_;
117 }
118
IsExtensionResumed() const119 bool IsExtensionResumed() const
120 {
121 return isExtensionResumed_;
122 }
123
124 private:
125 bool isExtensionConnected_ = false;
126 bool isExtensionDisconnected_ = false;
127 bool isDlpAbilityOpened_ = false;
128 bool isDlpAbilityClosed_ = false;
129 bool isServiceDied_ = false;
130 bool isExtensionSuspended_ = false;
131 bool isExtensionResumed_ = false;
132 };
133 }
134
135 class ConnectionObserverTest : public testing::Test {
136 public:
137 static void SetUpTestCase(void);
138 static void TearDownTestCase(void);
139 void SetUp();
140 void TearDown();
141 };
142
SetUpTestCase(void)143 void ConnectionObserverTest::SetUpTestCase(void) {}
144
TearDownTestCase(void)145 void ConnectionObserverTest::TearDownTestCase(void) {}
146
SetUp(void)147 void ConnectionObserverTest::SetUp(void) {}
148
TearDown(void)149 void ConnectionObserverTest::TearDown(void) {}
150
151 /**
152 * @tc.name: ConnectionObserver_Data_0100
153 * @tc.desc: ConnectionData test.
154 * @tc.type: FUNC
155 * @tc.require: SR000H19UG
156 */
157 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Data_0100, TestSize.Level1)
158 {
159 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Data_0100 start");
160
161 ConnectionData connectionData;
162 connectionData.extensionPid = TEST_PID;
163 connectionData.extensionUid = TEST_UID;
164 connectionData.extensionBundleName = TEST_BUNDLE_NAME;
165 connectionData.extensionModuleName = TEST_MODULE_NAME;
166 connectionData.extensionName = TEST_ABILITY_NAME;
167 connectionData.extensionType = OHOS::AppExecFwk::ExtensionAbilityType::SERVICE;
168 connectionData.callerPid = TEST_CALLER_PID;
169 connectionData.callerUid = TEST_CALLER_UID;
170 connectionData.callerName = TEST_CALLER_NAME;
171
172 Parcel data;
173 EXPECT_TRUE(connectionData.Marshalling(data));
174
175 std::shared_ptr<ConnectionData> readedData(ConnectionData::Unmarshalling(data));
176 EXPECT_TRUE(readedData);
177
178 EXPECT_EQ(connectionData.extensionPid, readedData->extensionPid);
179 EXPECT_EQ(connectionData.extensionUid, readedData->extensionUid);
180 EXPECT_EQ(connectionData.extensionBundleName, readedData->extensionBundleName);
181 EXPECT_EQ(connectionData.extensionModuleName, readedData->extensionModuleName);
182 EXPECT_EQ(connectionData.extensionName, readedData->extensionName);
183 EXPECT_EQ(connectionData.callerPid, readedData->callerPid);
184 EXPECT_EQ(connectionData.callerUid, readedData->callerUid);
185 EXPECT_EQ(connectionData.callerName, readedData->callerName);
186
187 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Data_0100 end");
188 }
189
190 #ifdef WITH_DLP
191 /**
192 * @tc.name: ConnectionObserver_Data_0200
193 * @tc.desc: DlpState data test.
194 * @tc.type: FUNC
195 * @tc.require: AR000H1PGT
196 */
197 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Data_0200, TestSize.Level1)
198 {
199 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Data_0200 start");
200
201 DlpStateData dlpData;
202 dlpData.targetPid = TEST_PID;
203 dlpData.targetUid = TEST_UID;
204 dlpData.targetBundleName = TEST_BUNDLE_NAME;
205 dlpData.targetModuleName = TEST_MODULE_NAME;
206 dlpData.targetAbilityName = TEST_ABILITY_NAME;
207 dlpData.callerPid = TEST_CALLER_PID;
208 dlpData.callerUid = TEST_CALLER_UID;
209 dlpData.callerName = TEST_CALLER_NAME;
210
211 Parcel data;
212 EXPECT_TRUE(dlpData.Marshalling(data));
213
214 std::shared_ptr<DlpStateData> readedData(DlpStateData::Unmarshalling(data));
215 EXPECT_TRUE(readedData);
216
217 EXPECT_EQ(dlpData.targetPid, readedData->targetPid);
218 EXPECT_EQ(dlpData.targetUid, readedData->targetUid);
219 EXPECT_EQ(dlpData.targetBundleName, readedData->targetBundleName);
220 EXPECT_EQ(dlpData.targetModuleName, readedData->targetModuleName);
221 EXPECT_EQ(dlpData.targetAbilityName, readedData->targetAbilityName);
222 EXPECT_EQ(dlpData.callerUid, readedData->callerUid);
223 EXPECT_EQ(dlpData.callerPid, readedData->callerPid);
224 EXPECT_EQ(dlpData.callerName, readedData->callerName);
225
226 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Data_0200 end");
227 }
228
229 /**
230 * @tc.name: ConnectionObserver_Data_0300
231 * @tc.desc: DlpState data test.
232 * @tc.type: FUNC
233 * @tc.require: issueI58213
234 */
235 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Data_0300, TestSize.Level1)
236 {
237 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Data_0300 start");
238
239 DlpConnectionInfo info;
240 info.dlpUid = TEST_UID;
241 info.openedAbilityCount = 1;
242
243 Parcel data;
244 EXPECT_TRUE(info.Marshalling(data));
245
246 std::shared_ptr<DlpConnectionInfo> readedData(DlpConnectionInfo::Unmarshalling(data));
247 EXPECT_TRUE(readedData);
248
249 EXPECT_EQ(info.dlpUid, readedData->dlpUid);
250 EXPECT_EQ(info.openedAbilityCount, readedData->openedAbilityCount);
251
252 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Data_0300 end");
253 }
254
255 /**
256 * @tc.name: ConnectionObserver_Observer_0100
257 * @tc.desc: test observer callback.
258 * @tc.type: FUNC
259 * @tc.require: issueI58213
260 */
261 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0100, TestSize.Level1)
262 {
263 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0100 start");
264
265 auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_;
266 EXPECT_TRUE(clientImpl);
267
268 std::vector<DlpConnectionInfo> infos;
269 auto result = ConnectionObserverClient::GetInstance().GetDlpConnectionInfos(infos);
270 EXPECT_EQ(result, AAFwk::CHECK_PERMISSION_FAILED);
271
272 std::vector<ConnectionData> connectionDatas;
273 result = ConnectionObserverClient::GetInstance().GetConnectionData(connectionDatas);
274 EXPECT_EQ(result, AAFwk::CHECK_PERMISSION_FAILED);
275
276 std::shared_ptr<MyConnectionObserver> myObserver = std::make_shared<MyConnectionObserver>();
277 clientImpl->userObservers_.emplace(myObserver);
278 ConnectionObserverClient::GetInstance().RegisterObserver(myObserver);
279
280 ConnectionData connectionData;
281 clientImpl->HandleExtensionConnected(connectionData);
282 EXPECT_TRUE(myObserver->IsExtensionConnected());
283
284 clientImpl->HandleExtensionDisconnected(connectionData);
285 EXPECT_TRUE(myObserver->IsExtensionDisconnected());
286
287 clientImpl->HandleExtensionSuspended(connectionData);
288 EXPECT_TRUE(myObserver->IsExtensionSuspended());
289
290 clientImpl->HandleExtensionResumed(connectionData);
291 EXPECT_TRUE(myObserver->IsExtensionResumed());
292
293 DlpStateData dlpData;
294 clientImpl->HandleDlpAbilityOpened(dlpData);
295 EXPECT_TRUE(myObserver->IsDlpAbilityOpened());
296
297 clientImpl->HandleDlpAbilityClosed(dlpData);
298 EXPECT_TRUE(myObserver->IsDlpAbilityClosed());
299
300 myObserver->OnServiceDied();
301 ConnectionObserverClient::GetInstance().UnregisterObserver(myObserver);
302
303 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0100 end");
304 }
305
306 /**
307 * @tc.name: ConnectionObserver_Observer_0200
308 * @tc.desc: test observer callback.
309 * @tc.type: FUNC
310 * @tc.require: issueI58213
311 */
312 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0200, TestSize.Level1)
313 {
314 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0200 start");
315
316 auto currentID = GetSelfTokenID();
317 AppExecFwk::MockNativeToken::SetNativeToken();
318
319 auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_;
320 EXPECT_TRUE(clientImpl);
321
322 std::vector<DlpConnectionInfo> infos;
323 auto result = ConnectionObserverClient::GetInstance().GetDlpConnectionInfos(infos);
324 EXPECT_EQ(result, ERR_OK);
325
326 std::vector<ConnectionData> connectionDatas;
327 result = ConnectionObserverClient::GetInstance().GetConnectionData(connectionDatas);
328 EXPECT_EQ(result, ERR_OK);
329
330 SetSelfTokenID(currentID);
331 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0200 end");
332 }
333
334 /**
335 * @tc.name: ConnectionObserver_Observer_0300
336 * @tc.desc: test observer callback.
337 * @tc.type: FUNC
338 * @tc.require: issueI58213
339 */
340 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0300, TestSize.Level1)
341 {
342 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0300 start");
343
344 auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_;
345
346 std::shared_ptr<MyConnectionObserver> myObserver = nullptr;
347 clientImpl->userObservers_.emplace(myObserver);
348 ConnectionData connectionData;
349 clientImpl->HandleExtensionSuspended(connectionData);
350 clientImpl->HandleExtensionResumed(connectionData);
351 EXPECT_FALSE(connectionData.isSuspended);
352
353 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0300 end");
354 }
355
356 /**
357 * @tc.name: ConnectionObserver_Observer_0400
358 * @tc.desc: test observer callback.
359 * @tc.type: FUNC
360 * @tc.require: issueI58213
361 */
362 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0400, TestSize.Level1)
363 {
364 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0400 start");
365
366 auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_;
367 EXPECT_TRUE(clientImpl);
368 ConnectionObserverStubImpl connectionObserverStubImpl(clientImpl);
369
370 MessageParcel data;
371 MessageParcel reply;
372 MessageOption option;
373 connectionObserverStubImpl.OnRemoteRequest(
374 IConnectionObserver::ON_EXTENSION_SUSPENDED, data, reply, option);
375 connectionObserverStubImpl.OnRemoteRequest(
376 IConnectionObserver::ON_EXTENSION_RESUMED, data, reply, option);
377
378 ConnectionData connectionData;
379 connectionData.extensionPid = TEST_PID;
380 connectionData.extensionUid = TEST_UID;
381 connectionData.extensionBundleName = TEST_BUNDLE_NAME;
382 connectionData.extensionModuleName = TEST_MODULE_NAME;
383 connectionData.extensionName = TEST_ABILITY_NAME;
384 connectionData.extensionType = OHOS::AppExecFwk::ExtensionAbilityType::SERVICE;
385 connectionData.callerPid = TEST_CALLER_PID;
386 connectionData.callerUid = TEST_CALLER_UID;
387 connectionData.callerName = TEST_CALLER_NAME;
388
389 EXPECT_TRUE(connectionData.Marshalling(data));
390 connectionObserverStubImpl.OnRemoteRequest(
391 IConnectionObserver::ON_EXTENSION_SUSPENDED, data, reply, option);
392 connectionObserverStubImpl.OnRemoteRequest(
393 IConnectionObserver::ON_EXTENSION_RESUMED, data, reply, option);
394
395 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0400 end");
396 }
397
398 /**
399 * @tc.name: ConnectionObserver_Observer_0500
400 * @tc.desc: test observer callback.
401 * @tc.type: FUNC
402 * @tc.require: issueI58213
403 */
404 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0500, TestSize.Level1)
405 {
406 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0500 start");
407
408 auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_;
409
410 ConnectionObserverStubImpl connectionObserverStubImpl(nullptr);
411
412 ConnectionData connectionData;
413 connectionObserverStubImpl.OnExtensionSuspended(connectionData);
414 connectionObserverStubImpl.OnExtensionResumed(connectionData);
415 EXPECT_FALSE(connectionData.isSuspended);
416
417 TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0500 end");
418 }
419 #endif // WITH_DLP
420 } // namespace AbilityRuntime
421 } // namespace OHOS
422