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 #include <gtest/gtest.h> 17 #include <string> 18 #include <vector> 19 #define private public 20 #define protected public 21 #include "iplugin.h" 22 #undef protected 23 #undef private 24 #include "func_code.h" 25 #include "iplugin_mock.h" 26 27 using namespace testing::ext; 28 using namespace testing; 29 30 namespace OHOS { 31 namespace EDM { 32 namespace TEST { 33 class IPluginTest : public testing::Test { 34 protected: SetUp()35 void SetUp() override {} 36 TearDown()37 void TearDown() override {} 38 }; 39 40 /** 41 * @tc.name: TestIsGlobalPolicy 42 * @tc.desc: Test IsGlobalPolicy func. 43 * @tc.type: FUNC 44 */ 45 HWTEST_F(IPluginTest, TestIsGlobalPolicy, TestSize.Level1) 46 { 47 IPluginMock iplugin1; 48 EXPECT_TRUE(iplugin1.IsGlobalPolicy()); 49 iplugin1.MockSetPolicyName("test"); 50 std::string mergeJsonData; 51 int32_t userId100 = 100; 52 ErrCode err = iplugin1.GetOthersMergePolicyData("com.edm.test.demo", userId100, mergeJsonData); 53 EXPECT_TRUE(err == ERR_OK); 54 MessageParcel reply; 55 err = iplugin1.WritePolicyToParcel("name:test", reply); 56 EXPECT_TRUE(err == ERR_OK); 57 } 58 59 /** 60 * @tc.name: TestPolicyPermissionConfig 61 * @tc.desc: Test PolicyPermissionConfig struct. 62 * @tc.type: FUNC 63 */ 64 HWTEST_F(IPluginTest, TestPolicyPermissionConfig, TestSize.Level1) 65 { 66 IPlugin::PolicyPermissionConfig config1 = IPlugin::PolicyPermissionConfig(); 67 EXPECT_TRUE(config1.apiType == IPlugin::ApiType::UNKNOWN); 68 69 IPlugin::PolicyPermissionConfig config2 = IPlugin::PolicyPermissionConfig("test_permission", 70 IPlugin::PermissionType::SUPER_DEVICE_ADMIN, IPlugin::ApiType::PUBLIC); 71 EXPECT_TRUE(config2.typePermissions[IPlugin::PermissionType::SUPER_DEVICE_ADMIN] == "test_permission"); 72 EXPECT_TRUE(config2.apiType == IPlugin::ApiType::PUBLIC); 73 74 std::map<std::string, std::map<IPlugin::PermissionType, std::string>> tagPermissions; 75 std::map<IPlugin::PermissionType, std::string> typePermissionsForTag1; 76 std::map<IPlugin::PermissionType, std::string> typePermissionsForTag2; 77 typePermissionsForTag1.emplace(IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, "permission1"); 78 typePermissionsForTag2.emplace(IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, "permission2"); 79 tagPermissions.emplace("tag1", typePermissionsForTag1); 80 tagPermissions.emplace("tag2", typePermissionsForTag2); 81 IPlugin::PolicyPermissionConfig config3 = IPlugin::PolicyPermissionConfig(tagPermissions, IPlugin::ApiType::SYSTEM); 82 EXPECT_TRUE(config3.tagPermissions.size() == 2); 83 EXPECT_TRUE(config3.apiType == IPlugin::ApiType::SYSTEM); 84 } 85 86 /** 87 * @tc.name: TestGetApiType 88 * @tc.desc: Test GetApiType func. 89 * @tc.type: FUNC 90 */ 91 HWTEST_F(IPluginTest, TestGetApiType, TestSize.Level1) 92 { 93 FuncOperateType operaType = FuncOperateType::GET; 94 IPluginMock::ApiType ret; 95 96 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap1; 97 IPluginMock::PolicyPermissionConfig permissionConfig1; 98 std::unique_ptr<IPlugin> iplugin1 = std::make_unique<IPluginMock>(); 99 permissionMap1[operaType] = permissionConfig1; 100 iplugin1->permissionMap_ = permissionMap1; 101 iplugin1->permissionConfig_ = permissionConfig1; 102 ret = iplugin1->GetApiType(operaType); 103 EXPECT_TRUE(ret == IPluginMock::ApiType::UNKNOWN); 104 105 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap2; 106 IPluginMock::PolicyPermissionConfig permissionConfig2; 107 std::unique_ptr<IPlugin> iplugin2 = std::make_unique<IPluginMock>(); 108 iplugin2->permissionMap_ = permissionMap2; 109 permissionConfig2.apiType = IPluginMock::ApiType::PUBLIC; 110 iplugin2->permissionConfig_ = permissionConfig2; 111 ret = iplugin2->GetApiType(operaType); 112 EXPECT_TRUE(ret == IPluginMock::ApiType::PUBLIC); 113 114 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap3; 115 IPluginMock::PolicyPermissionConfig permissionConfig3; 116 std::unique_ptr<IPlugin> iplugin3 = std::make_unique<IPluginMock>(); 117 permissionConfig3.apiType = IPluginMock::ApiType::PUBLIC; 118 permissionMap3[operaType] = permissionConfig3; 119 iplugin3->permissionMap_ = permissionMap3; 120 ret = iplugin3->GetApiType(operaType); 121 EXPECT_TRUE(ret == IPluginMock::ApiType::PUBLIC); 122 123 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap4; 124 IPluginMock::PolicyPermissionConfig permissionConfig4; 125 std::unique_ptr<IPlugin> iplugin4 = std::make_unique<IPluginMock>(); 126 permissionConfig4.apiType = IPluginMock::ApiType::UNKNOWN; 127 permissionMap4[operaType] = permissionConfig4; 128 iplugin4->permissionConfig_ = permissionConfig4; 129 ret = iplugin4->GetApiType(operaType); 130 EXPECT_TRUE(ret == IPluginMock::ApiType::UNKNOWN); 131 } 132 133 /** 134 * @tc.name: TestGetPermissionWhenIfEstablished 135 * @tc.desc: Test GetPermission func when The If Condition is Met. 136 * @tc.type: FUNC 137 */ 138 HWTEST_F(IPluginTest, TestGetPermissionWhenIfEstablished, TestSize.Level1) 139 { 140 FuncOperateType operaType = FuncOperateType::GET; 141 std::string permissionTag = "permissionTag"; 142 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap; 143 IPluginMock::PolicyPermissionConfig permissionConfig; 144 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 145 146 permissionMap[operaType] = permissionConfig; 147 iplugin->permissionMap_ = permissionMap; 148 iplugin->permissionConfig_ = permissionConfig; 149 std::string ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag); 150 std::string checkRet = NONE_PERMISSION_MATCH; 151 EXPECT_TRUE(ret == checkRet); 152 } 153 154 /** 155 * @tc.name: TestGetPermissionWithOnePermission 156 * @tc.desc: Test GetPermission func when add one permission. 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(IPluginTest, TestGetPermissionWithOnePermission, TestSize.Level1) 160 { 161 FuncOperateType operaType1 = FuncOperateType::GET; 162 FuncOperateType operaType2 = FuncOperateType::SET; 163 std::string permissionTag = ""; 164 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap; 165 166 std::map<IPlugin::PermissionType, std::string> typePermissions1; 167 std::map<IPlugin::PermissionType, std::string> typePermissions2; 168 typePermissions1.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, 169 "test_permission1"); 170 typePermissions2.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, 171 "test_permission2"); 172 IPluginMock::PolicyPermissionConfig permissionConfig1 = IPluginMock::PolicyPermissionConfig(typePermissions1, 173 IPlugin::ApiType::PUBLIC); 174 IPluginMock::PolicyPermissionConfig permissionConfig2 = IPluginMock::PolicyPermissionConfig(typePermissions2, 175 IPlugin::ApiType::PUBLIC); 176 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 177 178 permissionMap[operaType1] = permissionConfig1; 179 permissionMap[operaType2] = permissionConfig2; 180 iplugin->permissionMap_ = permissionMap; 181 std::string ret = iplugin->GetPermission(operaType1, IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag); 182 EXPECT_TRUE(ret == "test_permission1"); 183 ret = iplugin->GetPermission(operaType1, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permissionTag); 184 EXPECT_TRUE(ret == "test_permission1"); 185 } 186 187 /** 188 * @tc.name: TestGetPermissionWithOnePermissionAndTag 189 * @tc.desc: Test GetPermission func when add one permission with tag. 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(IPluginTest, TestGetPermissionWithOnePermissionAndTag, TestSize.Level1) 193 { 194 FuncOperateType operaType = FuncOperateType::GET; 195 std::string permissionTag1 = "TEST_API1"; 196 std::string permissionTag2 = "TEST_API2"; 197 std::string permission1 = "test_permission1"; 198 std::string permission2 = "test_permission2"; 199 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap; 200 201 std::map<std::string, std::map<IPlugin::PermissionType, std::string>> tagPermissions; 202 std::map<IPlugin::PermissionType, std::string> typePermissions1; 203 std::map<IPlugin::PermissionType, std::string> typePermissions2; 204 typePermissions1.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permission1); 205 typePermissions2.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permission2); 206 tagPermissions.emplace(permissionTag1, typePermissions1); 207 tagPermissions.emplace(permissionTag2, typePermissions2); 208 IPluginMock::PolicyPermissionConfig permissionConfig = IPluginMock::PolicyPermissionConfig(tagPermissions, 209 IPlugin::ApiType::PUBLIC); 210 211 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 212 213 iplugin->permissionMap_ = permissionMap; 214 iplugin->permissionConfig_ = permissionConfig; 215 std::string ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag1); 216 EXPECT_TRUE(ret == permission1); 217 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permissionTag1); 218 EXPECT_TRUE(ret == permission1); 219 } 220 221 /** 222 * @tc.name: TestGetPermissionWithTwoPermission 223 * @tc.desc: Test GetPermission func when add two permissions. 224 * @tc.type: FUNC 225 */ 226 HWTEST_F(IPluginTest, TestGetPermissionWithTwoPermission, TestSize.Level1) 227 { 228 FuncOperateType operaType = FuncOperateType::GET; 229 std::string permissionTag = ""; 230 std::string permission1 = "test_permission1"; 231 std::string permission2 = "test_permission2"; 232 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap; 233 234 std::map<IPlugin::PermissionType, std::string> typePermissions; 235 typePermissions.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permission1); 236 typePermissions.emplace(IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permission2); 237 IPluginMock::PolicyPermissionConfig permissionConfig = IPluginMock::PolicyPermissionConfig(typePermissions, 238 IPlugin::ApiType::PUBLIC); 239 240 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 241 iplugin->permissionMap_ = permissionMap; 242 iplugin->permissionConfig_ = permissionConfig; 243 std::string ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag); 244 EXPECT_TRUE(ret == permission1); 245 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permissionTag); 246 EXPECT_TRUE(ret == permission2); 247 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::UNKNOWN, permissionTag); 248 EXPECT_TRUE(ret == NONE_PERMISSION_MATCH); 249 } 250 251 /** 252 * @tc.name: TestGetPermissionWithTwoPermissionAndTag 253 * @tc.desc: Test GetPermission func when add two permissions with tag. 254 * @tc.type: FUNC 255 */ 256 HWTEST_F(IPluginTest, TestGetPermissionWithTwoPermissionAndTag, TestSize.Level1) 257 { 258 FuncOperateType operaType = FuncOperateType::GET; 259 std::string permissionTag1 = "TEST_API1"; 260 std::string permissionTag2 = "TEST_API2"; 261 std::string permission1 = "test_permission1"; 262 std::string permission2 = "test_permission2"; 263 std::string permission3 = "test_permission3"; 264 std::string permission4 = "test_permission4"; 265 std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap; 266 267 std::map<std::string, std::map<IPlugin::PermissionType, std::string>> tagPermissions; 268 std::map<IPlugin::PermissionType, std::string> typePermissions1; 269 std::map<IPlugin::PermissionType, std::string> typePermissions2; 270 typePermissions1.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permission1); 271 typePermissions1.emplace(IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permission2); 272 typePermissions2.emplace(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permission3); 273 typePermissions2.emplace(IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permission4); 274 tagPermissions.emplace(permissionTag1, typePermissions1); 275 tagPermissions.emplace(permissionTag2, typePermissions2); 276 IPluginMock::PolicyPermissionConfig permissionConfig = IPluginMock::PolicyPermissionConfig(tagPermissions, 277 IPlugin::ApiType::PUBLIC); 278 279 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 280 281 iplugin->permissionMap_ = permissionMap; 282 iplugin->permissionConfig_ = permissionConfig; 283 std::string ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag1); 284 EXPECT_TRUE(ret == permission1); 285 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permissionTag1); 286 EXPECT_TRUE(ret == permission2); 287 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag2); 288 EXPECT_TRUE(ret == permission3); 289 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, permissionTag2); 290 EXPECT_TRUE(ret == permission4); 291 ret = iplugin->GetPermission(operaType, IPlugin::PermissionType::UNKNOWN, permissionTag1); 292 EXPECT_TRUE(ret == NONE_PERMISSION_MATCH); 293 } 294 295 /** 296 * @tc.name: TestSetExtensionPlugin 297 * @tc.desc: Test SetExtensionPlugin func. 298 * @tc.type: FUNC 299 */ 300 HWTEST_F(IPluginTest, TestSetExtensionPlugin, TestSize.Level1) 301 { 302 std::shared_ptr<IPlugin> extensionPlugin = std::make_shared<IPluginMock>(); 303 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 304 iplugin->SetExtensionPlugin(extensionPlugin); 305 EXPECT_TRUE(extensionPlugin == iplugin->GetExtensionPlugin()); 306 iplugin->ResetExtensionPlugin(); 307 EXPECT_TRUE(iplugin->GetExtensionPlugin() == nullptr); 308 } 309 310 /** 311 * @tc.name: TestSetExecuteStrategy 312 * @tc.desc: Test SetExecuteStrategy func. 313 * @tc.type: FUNC 314 */ 315 HWTEST_F(IPluginTest, TestSetExecuteStrategy, TestSize.Level1) 316 { 317 std::shared_ptr<IPluginExecuteStrategy> strategy = std::make_shared<IPluginExecuteStrategy>(); 318 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 319 iplugin->SetExecuteStrategy(strategy); 320 EXPECT_TRUE(strategy == iplugin->GetExecuteStrategy()); 321 } 322 323 /** 324 * @tc.name: TestSetPluginType 325 * @tc.desc: Test SetPluginType func. 326 * @tc.type: FUNC 327 */ 328 HWTEST_F(IPluginTest, TestSetPluginType, TestSize.Level1) 329 { 330 IPluginMock::PluginType type = IPluginMock::PluginType::BASIC; 331 std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>(); 332 iplugin->SetPluginType(type); 333 EXPECT_TRUE(type == iplugin->GetPluginType()); 334 } 335 } // namespace TEST 336 } // namespace EDM 337 } // namespace OHOS