1 /* 2 * Copyright (c) 2022-2023 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 #ifndef EDM_UNIT_TEST_IPLUGIN_TEMPLATE_TEST_H 17 #define EDM_UNIT_TEST_IPLUGIN_TEMPLATE_TEST_H 18 19 #include <gtest/gtest.h> 20 21 #include <map> 22 #include <string> 23 #include <vector> 24 25 #include "array_map_serializer.h" 26 #include "array_string_serializer.h" 27 #include "bool_serializer.h" 28 #include "func_code_utils.h" 29 #include "iplugin.h" 30 #include "ipolicy_serializer.h" 31 #include "json/json.h" 32 #include "json_serializer.h" 33 #include "map_string_serializer.h" 34 #include "plugin_manager.h" 35 #include "plugin_singleton.h" 36 #include "string_serializer.h" 37 38 namespace OHOS { 39 namespace EDM { 40 namespace TEST { 41 static bool g_visit = false; 42 namespace PLUGIN { 43 #ifndef ARRAY_TEST_PLUGIN 44 #define ARRAY_TEST_PLUGIN 45 46 class ArrayTestPlugin : public PluginSingleton<ArrayTestPlugin, std::vector<std::string>> { 47 public: InitPlugin(std::shared_ptr<IPluginTemplate<ArrayTestPlugin,std::vector<std::string>>> ptr)48 void InitPlugin(std::shared_ptr<IPluginTemplate<ArrayTestPlugin, std::vector<std::string>>> ptr) override 49 { 50 int policyCode = 10; 51 ptr->InitAttribute(policyCode, "ArrayTestPlugin", "ohos.permission.EDM_TEST_PERMISSION", 52 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 53 ptr->SetSerializer(ArrayStringSerializer::GetInstance()); 54 } 55 }; 56 57 #endif // ARRAY_TEST_PLUGIN 58 59 #ifndef BOOL_TEST_PLUGIN 60 #define BOOL_TEST_PLUGIN 61 62 class BoolTestPlugin : public PluginSingleton<BoolTestPlugin, bool> { 63 public: InitPlugin(std::shared_ptr<IPluginTemplate<BoolTestPlugin,bool>> ptr)64 void InitPlugin(std::shared_ptr<IPluginTemplate<BoolTestPlugin, bool>> ptr) override 65 { 66 int policyCode = 11; 67 ptr->InitAttribute(policyCode, "BoolTestPlugin", "ohos.permission.EDM_TEST_PERMISSION", 68 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 69 ptr->SetSerializer(BoolSerializer::GetInstance()); 70 } 71 }; 72 73 #endif // BOOL_TEST_PLUGIN 74 75 #ifndef MAP_TEST_PLUGIN 76 #define MAP_TEST_PLUGIN 77 78 class MapTestPlugin : public PluginSingleton<MapTestPlugin, std::map<std::string, std::string>> { 79 public: InitPlugin(std::shared_ptr<IPluginTemplate<MapTestPlugin,std::map<std::string,std::string>>> ptr)80 void InitPlugin(std::shared_ptr<IPluginTemplate<MapTestPlugin, std::map<std::string, std::string>>> ptr) override 81 { 82 int policyCode = 12; 83 ptr->InitAttribute(policyCode, "MapTestPlugin", "ohos.permission.EDM_TEST_PERMISSION", 84 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 85 ptr->SetSerializer(MapStringSerializer::GetInstance()); 86 } 87 }; 88 89 #endif // MAP_TEST_PLUGIN 90 91 #ifndef ARRAY_MAP_TEST_PLUGIN 92 #define ARRAY_MAP_TEST_PLUGIN 93 94 class ArrayMapTestPlugin : public PluginSingleton<ArrayMapTestPlugin, std::vector<std::map<std::string, std::string>>> { 95 public: InitPlugin(std::shared_ptr<IPluginTemplate<ArrayMapTestPlugin,std::vector<std::map<std::string,std::string>>>> ptr)96 void InitPlugin(std::shared_ptr<IPluginTemplate<ArrayMapTestPlugin, 97 std::vector<std::map<std::string, std::string>>>> ptr) override 98 { 99 int policyCode = 13; 100 ptr->InitAttribute(policyCode, "ArrayMapTestPlugin", "ohos.permission.EDM_TEST_PERMISSION", 101 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 102 ptr->SetSerializer(ArrayMapSerializer::GetInstance()); 103 } 104 }; 105 106 #endif // ARRAY_MAP_TEST_PLUGIN 107 108 #ifndef JSON_TEST_PLUGIN 109 #define JSON_TEST_PLUGIN 110 111 class JsonTestPlugin : public PluginSingleton<JsonTestPlugin, Json::Value> { 112 public: InitPlugin(std::shared_ptr<IPluginTemplate<JsonTestPlugin,Json::Value>> ptr)113 void InitPlugin(std::shared_ptr<IPluginTemplate<JsonTestPlugin, Json::Value>> ptr) override 114 { 115 int policyCode = 14; 116 ptr->InitAttribute(policyCode, "JsonTestPlugin", "ohos.permission.EDM_TEST_PERMISSION", 117 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 118 ptr->SetSerializer(JsonSerializer::GetInstance()); 119 } 120 }; 121 122 #endif // JSON_TEST_PLUGIN 123 124 #ifndef STRING_TEST_PLUGIN 125 #define STRING_TEST_PLUGIN 126 127 class StringTestPlugin : public PluginSingleton<StringTestPlugin, std::string> { 128 public: InitPlugin(std::shared_ptr<IPluginTemplate<StringTestPlugin,std::string>> ptr)129 void InitPlugin(std::shared_ptr<IPluginTemplate<StringTestPlugin, std::string>> ptr) override 130 { 131 int policyCode = 15; 132 ptr->InitAttribute(policyCode, "StringTestPlugin", "ohos.permission.EDM_TEST_PERMISSION", 133 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 134 ptr->SetSerializer(StringSerializer::GetInstance()); 135 } 136 }; 137 138 #endif // STRING_TEST_PLUGIN 139 140 class InitAttributePlg : public PluginSingleton<InitAttributePlg, Json::Value> { 141 public: InitPlugin(std::shared_ptr<IPluginTemplate<InitAttributePlg,Json::Value>> ptr)142 void InitPlugin(std::shared_ptr<IPluginTemplate<InitAttributePlg, Json::Value>> ptr) override 143 { 144 int policyCode = 20; 145 ptr->InitAttribute(policyCode, "InitAttributePlg", "ohos.permission.EDM_TEST_PERMISSION", 146 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 147 } 148 }; 149 150 class HandlePolicySupplierPlg : public PluginSingleton<HandlePolicySupplierPlg, Json::Value> { 151 public: SetSupplier()152 ErrCode SetSupplier() 153 { 154 g_visit = true; 155 return ERR_EDM_PARAM_ERROR; 156 } 157 RemoveSupplier()158 ErrCode RemoveSupplier() 159 { 160 g_visit = true; 161 return ERR_EDM_PARAM_ERROR; 162 } 163 InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicySupplierPlg,Json::Value>> ptr)164 void InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicySupplierPlg, Json::Value>> ptr) override 165 { 166 int policyCode = 21; 167 ptr->InitAttribute(policyCode, "HandlePolicySupplierPlg", "ohos.permission.EDM_TEST_PERMISSION", 168 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 169 ptr->SetSerializer(JsonSerializer::GetInstance()); 170 ptr->SetOnHandlePolicyListener(&HandlePolicySupplierPlg::SetSupplier, FuncOperateType::SET); 171 ptr->SetOnHandlePolicyListener(&HandlePolicySupplierPlg::RemoveSupplier, FuncOperateType::REMOVE); 172 } 173 }; 174 175 class HandlePolicyFunctionPlg : public PluginSingleton<HandlePolicyFunctionPlg, std::string> { 176 public: SetFunction(std::string & policyValue)177 ErrCode SetFunction(std::string &policyValue) 178 { 179 if (policyValue.empty()) { 180 policyValue = "testValue"; 181 } else { 182 policyValue = "newTestValue"; 183 } 184 return ERR_OK; 185 } 186 RemoveFunction(std::string & policyValue)187 ErrCode RemoveFunction(std::string &policyValue) 188 { 189 policyValue = ""; 190 return ERR_OK; 191 } 192 InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyFunctionPlg,std::string>> ptr)193 void InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyFunctionPlg, std::string>> ptr) override 194 { 195 int policyCode = 22; 196 ptr->InitAttribute(policyCode, "HandlePolicyFunctionPlg", "ohos.permission.EDM_TEST_PERMISSION", 197 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 198 ptr->SetSerializer(StringSerializer::GetInstance()); 199 ptr->SetOnHandlePolicyListener(&HandlePolicyFunctionPlg::SetFunction, FuncOperateType::SET); 200 ptr->SetOnHandlePolicyListener(&HandlePolicyFunctionPlg::RemoveFunction, FuncOperateType::REMOVE); 201 } 202 }; 203 204 class HandlePolicyBiFunctionPlg : public PluginSingleton<HandlePolicyBiFunctionPlg, std::string> { 205 public: SetFunction(std::string & data,std::string & currentData,int32_t userId)206 ErrCode SetFunction(std::string &data, std::string ¤tData, int32_t userId) 207 { 208 std::string errStr{"ErrorData"}; 209 if (data == errStr) { 210 return ERR_EDM_OPERATE_JSON; 211 } 212 currentData = data; 213 return ERR_OK; 214 } 215 RemoveFunction(std::string & data,std::string & currentData,int32_t userId)216 ErrCode RemoveFunction(std::string &data, std::string ¤tData, int32_t userId) 217 { 218 currentData = ""; 219 return ERR_OK; 220 } 221 InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyBiFunctionPlg,std::string>> ptr)222 void InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyBiFunctionPlg, std::string>> ptr) override 223 { 224 int policyCode = 23; 225 ptr->InitAttribute(policyCode, "HandlePolicyBiFunctionPlg", "ohos.permission.EDM_TEST_PERMISSION", 226 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 227 ptr->SetSerializer(StringSerializer::GetInstance()); 228 ptr->SetOnHandlePolicyListener(&HandlePolicyBiFunctionPlg::SetFunction, FuncOperateType::SET); 229 ptr->SetOnHandlePolicyListener(&HandlePolicyBiFunctionPlg::RemoveFunction, FuncOperateType::REMOVE); 230 } 231 }; 232 233 class HandleDoneBoolConsumerPlg : public PluginSingleton<HandleDoneBoolConsumerPlg, std::string> { 234 public: SetDone(bool isGlobalChanged)235 void SetDone(bool isGlobalChanged) { g_visit = true; } 236 RemoveDone(bool isGlobalChanged)237 void RemoveDone(bool isGlobalChanged) { g_visit = true; } 238 InitPlugin(std::shared_ptr<IPluginTemplate<HandleDoneBoolConsumerPlg,std::string>> ptr)239 void InitPlugin(std::shared_ptr<IPluginTemplate<HandleDoneBoolConsumerPlg, std::string>> ptr) override 240 { 241 int policyCode = 24; 242 ptr->InitAttribute(policyCode, "HandleDoneBoolConsumerPlg", "ohos.permission.EDM_TEST_PERMISSION", 243 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 244 ptr->SetSerializer(StringSerializer::GetInstance()); 245 ptr->SetOnHandlePolicyDoneListener(&HandleDoneBoolConsumerPlg::SetDone, FuncOperateType::SET); 246 ptr->SetOnHandlePolicyDoneListener(&HandleDoneBoolConsumerPlg::RemoveDone, FuncOperateType::REMOVE); 247 } 248 }; 249 250 class HandleDoneBiBoolConsumerPlg : public PluginSingleton<HandleDoneBiBoolConsumerPlg, std::string> { 251 public: SetDone(std::string & data,bool isGlobalChanged,int32_t userId)252 void SetDone(std::string &data, bool isGlobalChanged, int32_t userId) { g_visit = true; } 253 RemoveDone(std::string & data,bool isGlobalChanged,int32_t userId)254 void RemoveDone(std::string &data, bool isGlobalChanged, int32_t userId) { g_visit = true; } 255 InitPlugin(std::shared_ptr<IPluginTemplate<HandleDoneBiBoolConsumerPlg,std::string>> ptr)256 void InitPlugin(std::shared_ptr<IPluginTemplate<HandleDoneBiBoolConsumerPlg, std::string>> ptr) override 257 { 258 int policyCode = 25; 259 ptr->InitAttribute(policyCode, "HandleDoneBiBoolConsumerPlg", "ohos.permission.EDM_TEST_PERMISSION", 260 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 261 ptr->SetSerializer(StringSerializer::GetInstance()); 262 ptr->SetOnHandlePolicyDoneListener(&HandleDoneBiBoolConsumerPlg::SetDone, FuncOperateType::SET); 263 ptr->SetOnHandlePolicyDoneListener(&HandleDoneBiBoolConsumerPlg::RemoveDone, FuncOperateType::REMOVE); 264 } 265 }; 266 267 class AdminRemoveSupplierPlg : public PluginSingleton<AdminRemoveSupplierPlg, std::string> { 268 public: RemoveAdmin()269 ErrCode RemoveAdmin() 270 { 271 g_visit = true; 272 return ERR_OK; 273 } 274 InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveSupplierPlg,std::string>> ptr)275 void InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveSupplierPlg, std::string>> ptr) override 276 { 277 int policyCode = 26; 278 ptr->InitAttribute(policyCode, "AdminRemoveSupplierPlg", "ohos.permission.EDM_TEST_PERMISSION", 279 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 280 ptr->SetSerializer(StringSerializer::GetInstance()); 281 ptr->SetOnAdminRemoveListener(&AdminRemoveSupplierPlg::RemoveAdmin); 282 } 283 }; 284 285 class AdminRemoveBiFunctionPlg : public PluginSingleton<AdminRemoveBiFunctionPlg, std::string> { 286 public: RemoveAdmin(const std::string & adminName,std::string & data,int32_t userId)287 ErrCode RemoveAdmin(const std::string &adminName, std::string &data, int32_t userId) 288 { 289 g_visit = true; 290 return ERR_OK; 291 } 292 InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveBiFunctionPlg,std::string>> ptr)293 void InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveBiFunctionPlg, std::string>> ptr) override 294 { 295 int policyCode = 27; 296 ptr->InitAttribute(policyCode, "AdminRemoveBiFunctionPlg", "ohos.permission.EDM_TEST_PERMISSION", 297 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 298 ptr->SetSerializer(StringSerializer::GetInstance()); 299 ptr->SetOnAdminRemoveListener(&AdminRemoveBiFunctionPlg::RemoveAdmin); 300 } 301 }; 302 303 class AdminRemoveDoneRunnerPlg : public PluginSingleton<AdminRemoveDoneRunnerPlg, std::string> { 304 public: RemoveAdminDone()305 void RemoveAdminDone() { g_visit = true; } 306 InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveDoneRunnerPlg,std::string>> ptr)307 void InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveDoneRunnerPlg, std::string>> ptr) override 308 { 309 int policyCode = 28; 310 ptr->InitAttribute(policyCode, "AdminRemoveDoneRunnerPlg", "ohos.permission.EDM_TEST_PERMISSION", 311 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 312 ptr->SetSerializer(StringSerializer::GetInstance()); 313 ptr->SetOnAdminRemoveDoneListener(&AdminRemoveDoneRunnerPlg::RemoveAdminDone); 314 } 315 }; 316 317 class AdminRemoveDoneBiBiConsumerPlg : public PluginSingleton<AdminRemoveDoneBiBiConsumerPlg, std::string> { 318 public: RemoveAdminDone(const std::string & adminName,std::string & data,int32_t userId)319 void RemoveAdminDone(const std::string &adminName, std::string &data, int32_t userId) { g_visit = true; } 320 InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveDoneBiBiConsumerPlg,std::string>> ptr)321 void InitPlugin(std::shared_ptr<IPluginTemplate<AdminRemoveDoneBiBiConsumerPlg, std::string>> ptr) override 322 { 323 int policyCode = 29; 324 ptr->InitAttribute(policyCode, "AdminRemoveDoneBiBiConsumerPlg", "ohos.permission.EDM_TEST_PERMISSION", 325 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 326 ptr->SetSerializer(StringSerializer::GetInstance()); 327 ptr->SetOnAdminRemoveDoneListener(&AdminRemoveDoneBiBiConsumerPlg::RemoveAdminDone); 328 } 329 }; 330 331 class HandlePolicyJsonBiFunctionPlg : public PluginSingleton<HandlePolicyJsonBiFunctionPlg, Json::Value> { 332 public: SetFunction(Json::Value & data,Json::Value & currentData,int32_t userId)333 ErrCode SetFunction(Json::Value &data, Json::Value ¤tData, int32_t userId) 334 { 335 currentData = data; 336 return ERR_OK; 337 } 338 RemoveFunction(Json::Value & data,Json::Value & currentData,int32_t userId)339 ErrCode RemoveFunction(Json::Value &data, Json::Value ¤tData, int32_t userId) 340 { 341 currentData = Json::nullValue; 342 return ERR_OK; 343 } 344 InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyJsonBiFunctionPlg,Json::Value>> ptr)345 void InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyJsonBiFunctionPlg, Json::Value>> ptr) override 346 { 347 int policyCode = 30; 348 ptr->InitAttribute(policyCode, "HandlePolicyJsonBiFunctionPlg", "ohos.permission.EDM_TEST_PERMISSION", 349 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN); 350 ptr->SetSerializer(JsonSerializer::GetInstance()); 351 ptr->SetOnHandlePolicyListener(&HandlePolicyJsonBiFunctionPlg::SetFunction, FuncOperateType::SET); 352 ptr->SetOnHandlePolicyListener(&HandlePolicyJsonBiFunctionPlg::RemoveFunction, FuncOperateType::REMOVE); 353 } 354 }; 355 356 class HandlePolicyBiFunctionUnsavePlg : public PluginSingleton<HandlePolicyBiFunctionUnsavePlg, Json::Value> { 357 public: SetFunction(Json::Value & data,Json::Value & currentData,int32_t userId)358 ErrCode SetFunction(Json::Value &data, Json::Value ¤tData, int32_t userId) 359 { 360 currentData = data; 361 return ERR_OK; 362 } 363 RemoveFunction(Json::Value & data,Json::Value & currentData,int32_t userId)364 ErrCode RemoveFunction(Json::Value &data, Json::Value ¤tData, int32_t userId) 365 { 366 currentData = Json::nullValue; 367 return ERR_OK; 368 } 369 InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyBiFunctionUnsavePlg,Json::Value>> ptr)370 void InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyBiFunctionUnsavePlg, Json::Value>> ptr) override 371 { 372 int policyCode = 31; 373 ptr->InitAttribute(policyCode, "HandlePolicyBiFunctionUnsavePlg", "ohos.permission.EDM_TEST_PERMISSION", 374 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, false, true); 375 ptr->SetSerializer(JsonSerializer::GetInstance()); 376 ptr->SetOnHandlePolicyListener(&HandlePolicyBiFunctionUnsavePlg::SetFunction, FuncOperateType::SET); 377 ptr->SetOnHandlePolicyListener(&HandlePolicyBiFunctionUnsavePlg::RemoveFunction, FuncOperateType::REMOVE); 378 } 379 }; 380 381 class HandlePolicyReplyFunctionPlg : public PluginSingleton<HandlePolicyReplyFunctionPlg, std::string> { 382 public: SetFunction(std::string & data,MessageParcel & reply)383 ErrCode SetFunction(std::string &data, MessageParcel &reply) 384 { 385 g_visit = true; 386 return ERR_OK; 387 } 388 RemoveFunction(std::string & data,MessageParcel & reply)389 ErrCode RemoveFunction(std::string &data, MessageParcel &reply) 390 { 391 g_visit = true; 392 return ERR_OK; 393 } 394 InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyReplyFunctionPlg,std::string>> ptr)395 void InitPlugin(std::shared_ptr<IPluginTemplate<HandlePolicyReplyFunctionPlg, std::string>> ptr) override 396 { 397 int policyCode = 32; 398 ptr->InitAttribute(policyCode, "HandlePolicyReplyFunctionPlg", "ohos.permission.EDM_TEST_PERMISSION", 399 IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, false, true); 400 ptr->SetSerializer(StringSerializer::GetInstance()); 401 ptr->SetOnHandlePolicyListener(&HandlePolicyReplyFunctionPlg::SetFunction, FuncOperateType::SET); 402 ptr->SetOnHandlePolicyListener(&HandlePolicyReplyFunctionPlg::RemoveFunction, FuncOperateType::REMOVE); 403 } 404 }; 405 } // namespace PLUGIN 406 407 class PluginTemplateTest : public testing::Test { 408 protected: 409 void SetUp() override; 410 void TearDown() override; 411 }; 412 } // namespace TEST 413 } // namespace EDM 414 } // namespace OHOS 415 #endif // EDM_UNIT_TEST_IPLUGIN_TEMPLATE_TEST_H 416