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 "connection_data.h"
23 #include "connection_observer_client.h"
24 #include "connection_observer_client_impl.h"
25 #include "dlp_state_data.h"
26 #include "hilog_wrapper.h"
27 #include "parcel.h"
28
29 using namespace testing::ext;
30 using namespace testing;
31
32 namespace OHOS {
33 namespace AbilityRuntime {
34 namespace {
35 const int32_t TEST_PID = 10001;
36 const int32_t TEST_UID = 10002;
37 const std::string TEST_BUNDLE_NAME = "com.ohos.connnection.test";
38 const std::string TEST_MODULE_NAME = "entry";
39 const std::string TEST_ABILITY_NAME = "TestServiceExtension";
40 const int32_t TEST_CALLER_PID = 10003;
41 const int32_t TEST_CALLER_UID = 10004;
42 const std::string TEST_CALLER_NAME = "test_caller";
43
44 class MyConnectionObserver : public ConnectionObserver {
45 public:
MyConnectionObserver()46 MyConnectionObserver() {}
~MyConnectionObserver()47 ~MyConnectionObserver() {}
48
OnExtensionConnected(const ConnectionData & data)49 void OnExtensionConnected(const ConnectionData& data)
50 {
51 isExtensionConnected_ = true;
52 }
53
OnExtensionDisconnected(const ConnectionData & data)54 void OnExtensionDisconnected(const ConnectionData& data)
55 {
56 isExtensionDisconnected_ = true;
57 }
58
OnDlpAbilityOpened(const DlpStateData & data)59 void OnDlpAbilityOpened(const DlpStateData& data)
60 {
61 isDlpAbilityOpened_ = true;
62 }
63
OnDlpAbilityClosed(const DlpStateData & data)64 void OnDlpAbilityClosed(const DlpStateData& data)
65 {
66 isDlpAbilityClosed_ = true;
67 }
68
OnServiceDied()69 void OnServiceDied()
70 {
71 isServiceDied_ = true;
72 }
73
IsExtensionConnected() const74 bool IsExtensionConnected() const
75 {
76 return isExtensionConnected_;
77 }
78
IsExtensionDisconnected() const79 bool IsExtensionDisconnected() const
80 {
81 return isExtensionDisconnected_;
82 }
83
IsDlpAbilityOpened() const84 bool IsDlpAbilityOpened() const
85 {
86 return isDlpAbilityOpened_;
87 }
88
IsDlpAbilityClosed() const89 bool IsDlpAbilityClosed() const
90 {
91 return isDlpAbilityClosed_;
92 }
93
IsServiceDied() const94 bool IsServiceDied() const
95 {
96 return isServiceDied_;
97 }
98
99 private:
100 bool isExtensionConnected_ = false;
101 bool isExtensionDisconnected_ = false;
102 bool isDlpAbilityOpened_ = false;
103 bool isDlpAbilityClosed_ = false;
104 bool isServiceDied_ = false;
105 };
106 }
107
108 class ConnectionObserverTest : public testing::Test {
109 public:
110 static void SetUpTestCase(void);
111 static void TearDownTestCase(void);
112 void SetUp();
113 void TearDown();
114 };
115
SetUpTestCase(void)116 void ConnectionObserverTest::SetUpTestCase(void) {}
117
TearDownTestCase(void)118 void ConnectionObserverTest::TearDownTestCase(void) {}
119
SetUp(void)120 void ConnectionObserverTest::SetUp(void) {}
121
TearDown(void)122 void ConnectionObserverTest::TearDown(void) {}
123
124 /**
125 * @tc.name: ConnectionObserver_Data_0100
126 * @tc.desc: ConnectionData test.
127 * @tc.type: FUNC
128 * @tc.require: SR000H19UG
129 */
130 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Data_0100, TestSize.Level1)
131 {
132 HILOG_INFO("ConnectionObserver_Data_0100 start");
133
134 ConnectionData connectionData;
135 connectionData.extensionPid = TEST_PID;
136 connectionData.extensionUid = TEST_UID;
137 connectionData.extensionBundleName = TEST_BUNDLE_NAME;
138 connectionData.extensionModuleName = TEST_MODULE_NAME;
139 connectionData.extensionName = TEST_ABILITY_NAME;
140 connectionData.extensionType = OHOS::AppExecFwk::ExtensionAbilityType::SERVICE;
141 connectionData.callerPid = TEST_CALLER_PID;
142 connectionData.callerUid = TEST_CALLER_UID;
143 connectionData.callerName = TEST_CALLER_NAME;
144
145 Parcel data;
146 EXPECT_TRUE(connectionData.Marshalling(data));
147
148 std::shared_ptr<ConnectionData> readedData(ConnectionData::Unmarshalling(data));
149 EXPECT_TRUE(readedData);
150
151 EXPECT_EQ(connectionData.extensionPid, readedData->extensionPid);
152 EXPECT_EQ(connectionData.extensionUid, readedData->extensionUid);
153 EXPECT_EQ(connectionData.extensionBundleName, readedData->extensionBundleName);
154 EXPECT_EQ(connectionData.extensionModuleName, readedData->extensionModuleName);
155 EXPECT_EQ(connectionData.extensionName, readedData->extensionName);
156 EXPECT_EQ(connectionData.callerPid, readedData->callerPid);
157 EXPECT_EQ(connectionData.callerUid, readedData->callerUid);
158 EXPECT_EQ(connectionData.callerName, readedData->callerName);
159
160 HILOG_INFO("ConnectionObserver_Data_0100 end");
161 }
162
163 /**
164 * @tc.name: ConnectionObserver_Data_0200
165 * @tc.desc: DlpState data test.
166 * @tc.type: FUNC
167 * @tc.require: AR000H1PGT
168 */
169 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Data_0200, TestSize.Level1)
170 {
171 HILOG_INFO("ConnectionObserver_Data_0200 start");
172
173 DlpStateData dlpData;
174 dlpData.targetPid = TEST_PID;
175 dlpData.targetUid = TEST_UID;
176 dlpData.targetBundleName = TEST_BUNDLE_NAME;
177 dlpData.targetModuleName = TEST_MODULE_NAME;
178 dlpData.targetAbilityName = TEST_ABILITY_NAME;
179 dlpData.callerPid = TEST_CALLER_PID;
180 dlpData.callerUid = TEST_CALLER_UID;
181 dlpData.callerName = TEST_CALLER_NAME;
182
183 Parcel data;
184 EXPECT_TRUE(dlpData.Marshalling(data));
185
186 std::shared_ptr<DlpStateData> readedData(DlpStateData::Unmarshalling(data));
187 EXPECT_TRUE(readedData);
188
189 EXPECT_EQ(dlpData.targetPid, readedData->targetPid);
190 EXPECT_EQ(dlpData.targetUid, readedData->targetUid);
191 EXPECT_EQ(dlpData.targetBundleName, readedData->targetBundleName);
192 EXPECT_EQ(dlpData.targetModuleName, readedData->targetModuleName);
193 EXPECT_EQ(dlpData.targetAbilityName, readedData->targetAbilityName);
194 EXPECT_EQ(dlpData.callerUid, readedData->callerUid);
195 EXPECT_EQ(dlpData.callerPid, readedData->callerPid);
196 EXPECT_EQ(dlpData.callerName, readedData->callerName);
197
198 HILOG_INFO("ConnectionObserver_Data_0200 end");
199 }
200
201 /**
202 * @tc.name: ConnectionObserver_Data_0300
203 * @tc.desc: DlpState data test.
204 * @tc.type: FUNC
205 * @tc.require: issueI58213
206 */
207 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Data_0300, TestSize.Level1)
208 {
209 HILOG_INFO("ConnectionObserver_Data_0300 start");
210
211 DlpConnectionInfo info;
212 info.dlpUid = TEST_UID;
213 info.openedAbilityCount = 1;
214
215 Parcel data;
216 EXPECT_TRUE(info.Marshalling(data));
217
218 std::shared_ptr<DlpConnectionInfo> readedData(DlpConnectionInfo::Unmarshalling(data));
219 EXPECT_TRUE(readedData);
220
221 EXPECT_EQ(info.dlpUid, readedData->dlpUid);
222 EXPECT_EQ(info.openedAbilityCount, readedData->openedAbilityCount);
223
224 HILOG_INFO("ConnectionObserver_Data_0300 end");
225 }
226
227 /**
228 * @tc.name: ConnectionObserver_Observer_0100
229 * @tc.desc: test observer callback.
230 * @tc.type: FUNC
231 * @tc.require: issueI58213
232 */
233 HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0100, TestSize.Level1)
234 {
235 HILOG_INFO("ConnectionObserver_Observer_0100 start");
236
237 auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_;
238 EXPECT_TRUE(clientImpl);
239
240 std::vector<DlpConnectionInfo> infos;
241 ConnectionObserverClient::GetInstance().GetDlpConnectionInfos(infos);
242
243 std::shared_ptr<MyConnectionObserver> myObserver = std::make_shared<MyConnectionObserver>();
244 clientImpl->userObservers_.emplace(myObserver);
245 ConnectionObserverClient::GetInstance().RegisterObserver(myObserver);
246
247 ConnectionData connectionData;
248 clientImpl->HandleExtensionConnected(connectionData);
249 EXPECT_TRUE(myObserver->IsExtensionConnected());
250
251 clientImpl->HandleExtensionDisconnected(connectionData);
252 EXPECT_TRUE(myObserver->IsExtensionDisconnected());
253
254 DlpStateData dlpData;
255 clientImpl->HandleDlpAbilityOpened(dlpData);
256 EXPECT_TRUE(myObserver->IsDlpAbilityOpened());
257
258 clientImpl->HandleDlpAbilityClosed(dlpData);
259 EXPECT_TRUE(myObserver->IsDlpAbilityClosed());
260
261 myObserver->OnServiceDied();
262 ConnectionObserverClient::GetInstance().UnregisterObserver(myObserver);
263
264 HILOG_INFO("ConnectionObserver_Observer_0100 end");
265 }
266 } // namespace AbilityRuntime
267 } // namespace OHOS
268