1 /*
2 * Copyright (c) 2022-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 "plugin_manager_test.h"
17 #include <ipc_skeleton.h>
18 #include <iservice_registry.h>
19 #include "func_code_utils.h"
20 #define private public
21 #include "plugin_manager.h"
22 #undef private
23 #include "string_ex.h"
24 #include "system_ability_definition.h"
25
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::EDM;
29
30 namespace OHOS {
31 namespace EDM {
32 namespace TEST {
33 constexpr uint32_t INVAILD_PLUGIN_CODE = 10000;
34
SetUp()35 void PluginManagerTest::SetUp()
36 {
37 PluginManager::GetInstance()->AddPlugin(std::make_shared<TestPlugin>());
38 }
39
TearDown()40 void PluginManagerTest::TearDown()
41 {
42 PluginManager::GetInstance().reset();
43 }
44
45 /**
46 * @tc.name: TestGetInstance
47 * @tc.desc: Test PluginManager GetInstance func.
48 * @tc.type: FUNC
49 */
50 HWTEST_F(PluginManagerTest, TestGetInstance, TestSize.Level1)
51 {
52 ASSERT_TRUE(PluginManager::GetInstance() != nullptr);
53 ASSERT_TRUE(PluginManager::GetInstance().get() != nullptr);
54 }
55
56 /**
57 * @tc.name: TestGetPluginByFuncCode
58 * @tc.desc: Test PluginManager GetPluginByFuncCode func.
59 * @tc.type: FUNC
60 */
61 HWTEST_F(PluginManagerTest, TestGetPluginByFuncCode, TestSize.Level1)
62 {
63 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(
64 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0));
65 ASSERT_TRUE(plugin != nullptr);
66 ASSERT_TRUE(plugin->GetPolicyName() == "TestPlugin");
67 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByFuncCode(
68 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE)) == nullptr);
69 }
70
71 /**
72 * @tc.name: TestGetPluginByPolicyName
73 * @tc.desc: Test PluginManager GetPluginByPolicyName func.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(PluginManagerTest, TestGetPluginByPolicyName, TestSize.Level1)
77 {
78 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByPolicyName("TestPlugin");
79 ASSERT_TRUE(plugin != nullptr);
80 ASSERT_TRUE(plugin->GetCode() == 0);
81 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByPolicyName("XXXXExamplePlugin") == nullptr);
82 }
83
84 /**
85 * @tc.name: TestGetPluginByCode
86 * @tc.desc: Test PluginManager GetPluginByCode func.
87 * @tc.type: FUNC
88 */
89 HWTEST_F(PluginManagerTest, TestGetPluginByCode, TestSize.Level1)
90 {
91 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByCode(0);
92 ASSERT_TRUE(plugin != nullptr);
93 ASSERT_TRUE(plugin->GetPolicyName() == "TestPlugin");
94 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(INVAILD_PLUGIN_CODE) == nullptr);
95 }
96
97 /**
98 * @tc.name: TestEnhanceStrategyOnGetPolicy
99 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
100 * @tc.type: FUNC
101 */
102 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnGetPolicy, TestSize.Level1)
103 {
104 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
105 std::string policyData;
106 MessageParcel data;
107 MessageParcel reply;
108 ErrCode ret = strategy->OnGetExecute(
109 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
110 ASSERT_TRUE(ret == ERR_OK);
111 ret = strategy->OnGetExecute(
112 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, INVAILD_PLUGIN_CODE), policyData, data, reply, 0);
113 ASSERT_TRUE(ret == ERR_EDM_GET_POLICY_FAILED);
114 }
115
116 /**
117 * @tc.name: TestEnhanceStrategyOnSetPolicy
118 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
119 * @tc.type: FUNC
120 */
121 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnSetPolicy, TestSize.Level1)
122 {
123 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
124 MessageParcel data;
125 MessageParcel reply;
126 HandlePolicyData policyData;
127 ErrCode ret = strategy->OnSetExecute(
128 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
129 ASSERT_TRUE(ret == ERR_OK);
130 ret = strategy->OnSetExecute(
131 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE), data, reply, policyData, 0);
132 ASSERT_TRUE(ret == ERR_EDM_HANDLE_POLICY_FAILED);
133 }
134
135 /**
136 * @tc.name: TestSingleStrategyOnGetPolicy
137 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
138 * @tc.type: FUNC
139 */
140 HWTEST_F(PluginManagerTest, TestSingleStrategyOnGetPolicy, TestSize.Level1)
141 {
142 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::SINGLE);
143 std::string policyData;
144 MessageParcel data;
145 MessageParcel reply;
146 ErrCode ret = strategy->OnGetExecute(
147 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
148 ASSERT_TRUE(ret == ERR_OK);
149 ret = strategy->OnGetExecute(
150 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, INVAILD_PLUGIN_CODE), policyData, data, reply, 0);
151 ASSERT_TRUE(ret == ERR_EDM_GET_POLICY_FAILED);
152 }
153
154 /**
155 * @tc.name: TestSingleStrategyOnSetPolicy
156 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(PluginManagerTest, TestSingleStrategyOnSetPolicy, TestSize.Level1)
160 {
161 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::SINGLE);
162 MessageParcel data;
163 MessageParcel reply;
164 HandlePolicyData policyData;
165 ErrCode ret = strategy->OnSetExecute(
166 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
167 ASSERT_TRUE(ret == ERR_OK);
168 ret = strategy->OnSetExecute(
169 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE), data, reply, policyData, 0);
170 ASSERT_TRUE(ret == ERR_EDM_HANDLE_POLICY_FAILED);
171 }
172
173 /**
174 * @tc.name: TestReplaceStrategyOnGetPolicy
175 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
176 * @tc.type: FUNC
177 */
178 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnGetPolicy, TestSize.Level1)
179 {
180 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
181 std::string policyData;
182 MessageParcel data;
183 MessageParcel reply;
184 ErrCode ret = strategy->OnGetExecute(
185 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
186 ASSERT_TRUE(ret == ERR_OK);
187 ret = strategy->OnGetExecute(
188 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, INVAILD_PLUGIN_CODE), policyData, data, reply, 0);
189 ASSERT_TRUE(ret == ERR_EDM_GET_POLICY_FAILED);
190 }
191
192 /**
193 * @tc.name: TestReplaceStrategyOnSetPolicy
194 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
195 * @tc.type: FUNC
196 */
197 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnSetPolicy, TestSize.Level1)
198 {
199 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
200 MessageParcel data;
201 MessageParcel reply;
202 HandlePolicyData policyData;
203 ErrCode ret = strategy->OnSetExecute(
204 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
205 ASSERT_TRUE(ret == ERR_OK);
206 ret = strategy->OnSetExecute(
207 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE), data, reply, policyData, 0);
208 ASSERT_TRUE(ret == ERR_EDM_HANDLE_POLICY_FAILED);
209 }
210
211 /**
212 * @tc.name: TestEnhanceStrategyOnGetPolicyWithExtension
213 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnGetPolicyWithExtension, TestSize.Level1)
217 {
218 PluginManager::GetInstance()->AddExtensionPlugin(
219 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::ENHANCE);
220 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
221 std::string policyData;
222 MessageParcel data;
223 MessageParcel reply;
224 ErrCode ret = strategy->OnGetExecute(
225 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
226 ASSERT_TRUE(ret == ERR_OK);
227 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
228 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
229 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
230 }
231
232 /**
233 * @tc.name: TestEnhanceStrategyOnSetPolicyWithExtension
234 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnSetPolicyWithExtension, TestSize.Level1)
238 {
239 PluginManager::GetInstance()->AddExtensionPlugin(
240 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::ENHANCE);
241 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
242 MessageParcel data;
243 MessageParcel reply;
244 HandlePolicyData policyData;
245 ErrCode ret = strategy->OnSetExecute(
246 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
247 ASSERT_TRUE(ret == ERR_OK);
248 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
249 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
250 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
251 }
252
253 /**
254 * @tc.name: TestReplaceStrategyOnGetPolicyWithExtension
255 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnGetPolicyWithExtension, TestSize.Level1)
259 {
260 PluginManager::GetInstance()->AddExtensionPlugin(
261 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::REPLACE);
262 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
263 std::string policyData;
264 MessageParcel data;
265 MessageParcel reply;
266 ErrCode ret = strategy->OnGetExecute(
267 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
268 ASSERT_TRUE(ret == ERR_OK);
269 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
270 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
271 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
272 }
273
274 /**
275 * @tc.name: TestReplaceStrategyOnSetPolicyWithExtension
276 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
277 * @tc.type: FUNC
278 */
279 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnSetPolicyWithExtension, TestSize.Level1)
280 {
281 PluginManager::GetInstance()->AddExtensionPlugin(
282 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::REPLACE);
283 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
284 MessageParcel data;
285 MessageParcel reply;
286 HandlePolicyData policyData;
287 ErrCode ret = strategy->OnSetExecute(
288 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
289 ASSERT_TRUE(ret == ERR_OK);
290 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
291 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
292 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
293 }
294 } // namespace TEST
295 } // namespace EDM
296 } // namespace OHOS
297