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