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 <gtest/gtest.h> 17 #include <string> 18 #include <vector> 19 #include "array_string_serializer.h" 20 #define private public 21 #include "policy_manager.h" 22 #undef private 23 #include "utils.h" 24 25 using namespace testing::ext; 26 27 namespace OHOS { 28 namespace EDM { 29 namespace TEST { 30 const std::string TEST_ADMIN_NAME = "com.edm.test.demo"; 31 const std::string TEST_ADMIN_NAME1 = "com.edm.test.demo1"; 32 const std::string TEST_BOOL_POLICY_NAME = "testBoolPolicy"; 33 const std::string TEST_STRING_POLICY_NAME = "testStringPolicy"; 34 const std::string TEST_ADMIN_POLICY_VALUE = "adminPolicy"; 35 const std::string TEST_MERAGE_POLICY_VALUE = "mergedValue"; 36 const std::string TEST_MERAGE_POLICY_VALUE_ONE = "mergedValue1"; 37 constexpr int32_t TEST_USER_ID = 101; 38 constexpr int32_t DEFAULT_USERID = 100; 39 40 class PolicyManagerTest : public testing::Test { 41 public: SetUp()42 void SetUp() override 43 { 44 if (!policyMgr_) { 45 policyMgr_ = std::make_shared<PolicyManager>(); 46 } 47 std::vector<int32_t> userIds {TEST_USER_ID}; 48 policyMgr_->Init(userIds); 49 } 50 TearDown()51 void TearDown() override 52 { 53 policyMgr_ = nullptr; 54 } 55 56 std::shared_ptr<PolicyManager> policyMgr_; 57 }; 58 59 /** 60 * @tc.name: TestGetAdminByPolicyName 61 * @tc.desc: Test PolicyManager GetAdminByPolicyName func. 62 * @tc.type: FUNC 63 */ 64 HWTEST_F(PolicyManagerTest, TestGetAdminByPolicyName, TestSize.Level1) 65 { 66 ErrCode res; 67 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, "false", "true"); 68 ASSERT_TRUE(res == ERR_OK); 69 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME1, TEST_BOOL_POLICY_NAME, "true", "true"); 70 ASSERT_TRUE(res == ERR_OK); 71 72 std::unordered_map<std::string, std::string> adminPolicyValue; 73 res = policyMgr_->GetAdminByPolicyName(TEST_BOOL_POLICY_NAME, adminPolicyValue); 74 ASSERT_TRUE(res == ERR_OK); 75 ASSERT_TRUE(adminPolicyValue.size() == 2); 76 auto adminEntry = adminPolicyValue.find(TEST_ADMIN_NAME); 77 ASSERT_TRUE(adminEntry != adminPolicyValue.end() && adminEntry->second == "false"); 78 auto adminEntry1 = adminPolicyValue.find(TEST_ADMIN_NAME1); 79 ASSERT_TRUE(adminEntry1 != adminPolicyValue.end() && adminEntry1->second == "true"); 80 81 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, "", ""); 82 ASSERT_TRUE(res == ERR_OK); 83 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME1, TEST_BOOL_POLICY_NAME, "", ""); 84 ASSERT_TRUE(res == ERR_OK); 85 } 86 87 /** 88 * @tc.name: TestGetPolicy 89 * @tc.desc: Test PolicyManager GetPolicy func. 90 * @tc.type: FUNC 91 */ 92 HWTEST_F(PolicyManagerTest, TestGetPolicy, TestSize.Level1) 93 { 94 ErrCode res; 95 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_STRING_POLICY_NAME, TEST_ADMIN_POLICY_VALUE, 96 TEST_MERAGE_POLICY_VALUE); 97 ASSERT_TRUE(res == ERR_OK); 98 99 std::string policyValue; 100 res = policyMgr_->GetPolicy(TEST_ADMIN_NAME, TEST_STRING_POLICY_NAME, policyValue); 101 ASSERT_TRUE(res == ERR_OK); 102 ASSERT_TRUE(policyValue == TEST_ADMIN_POLICY_VALUE); 103 res = policyMgr_->GetPolicy("", TEST_STRING_POLICY_NAME, policyValue); 104 ASSERT_TRUE(res == ERR_OK); 105 ASSERT_TRUE(policyValue == TEST_MERAGE_POLICY_VALUE); 106 107 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME1, TEST_STRING_POLICY_NAME, "", TEST_MERAGE_POLICY_VALUE_ONE); 108 ASSERT_TRUE(res == ERR_OK); 109 110 policyValue = ""; 111 res = policyMgr_->GetPolicy(TEST_ADMIN_NAME1, TEST_STRING_POLICY_NAME, policyValue); 112 ASSERT_TRUE(res == ERR_EDM_POLICY_NOT_FIND); 113 ASSERT_TRUE(policyValue.empty()); 114 res = policyMgr_->GetPolicy("", TEST_STRING_POLICY_NAME, policyValue); 115 ASSERT_TRUE(res == ERR_OK); 116 ASSERT_TRUE(policyValue == TEST_MERAGE_POLICY_VALUE_ONE); 117 118 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_STRING_POLICY_NAME, "", ""); 119 ASSERT_TRUE(res == ERR_OK); 120 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME1, TEST_STRING_POLICY_NAME, "", ""); 121 ASSERT_TRUE(res == ERR_OK); 122 } 123 124 /** 125 * @tc.name: TestSetPolicy 126 * @tc.desc: Test PolicyManager SetPolicy func. 127 * @tc.type: FUNC 128 */ 129 HWTEST_F(PolicyManagerTest, TestSetPolicy, TestSize.Level1) 130 { 131 ErrCode res; 132 std::string adminPolicy; 133 std::string mergedPolicy; 134 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, "false", "true"); 135 ASSERT_TRUE(res == ERR_OK); 136 137 std::string policyValue; 138 res = policyMgr_->GetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, policyValue); 139 ASSERT_TRUE(res == ERR_OK); 140 ASSERT_TRUE(policyValue == "false"); 141 res = policyMgr_->GetPolicy("", TEST_BOOL_POLICY_NAME, policyValue); 142 ASSERT_TRUE(res == ERR_OK); 143 ASSERT_TRUE(policyValue == "true"); 144 145 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME1, TEST_BOOL_POLICY_NAME, "true", "true"); 146 ASSERT_TRUE(res == ERR_OK); 147 res = policyMgr_->GetPolicy(TEST_ADMIN_NAME1, TEST_BOOL_POLICY_NAME, policyValue); 148 ASSERT_TRUE(res == ERR_OK); 149 ASSERT_TRUE(policyValue == "true"); 150 res = policyMgr_->GetPolicy("", TEST_BOOL_POLICY_NAME, policyValue); 151 ASSERT_TRUE(res == ERR_OK); 152 ASSERT_TRUE(policyValue == "true"); 153 154 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, "", ""); 155 ASSERT_TRUE(res == ERR_OK); 156 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME1, TEST_BOOL_POLICY_NAME, "", ""); 157 ASSERT_TRUE(res == ERR_OK); 158 } 159 160 /** 161 * @tc.name: TestGetAllPolicyByAdmin 162 * @tc.desc: Test PolicyManager GetAllPolicyByAdmin func. 163 * @tc.type: FUNC 164 */ 165 HWTEST_F(PolicyManagerTest, TestGetAllPolicyByAdmin, TestSize.Level1) 166 { 167 ErrCode res; 168 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_STRING_POLICY_NAME, TEST_ADMIN_POLICY_VALUE, 169 TEST_MERAGE_POLICY_VALUE); 170 ASSERT_TRUE(res == ERR_OK); 171 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, "true", "true"); 172 ASSERT_TRUE(res == ERR_OK); 173 174 std::unordered_map<std::string, std::string> allPolicyValue; 175 res = policyMgr_->GetAllPolicyByAdmin(TEST_ADMIN_NAME, allPolicyValue); 176 ASSERT_TRUE(res == ERR_OK); 177 ASSERT_TRUE(allPolicyValue.size() == 2); 178 auto stringEntry = allPolicyValue.find(TEST_STRING_POLICY_NAME); 179 ASSERT_TRUE(stringEntry != allPolicyValue.end() && stringEntry->second == TEST_ADMIN_POLICY_VALUE); 180 auto boolEntry = allPolicyValue.find(TEST_BOOL_POLICY_NAME); 181 ASSERT_TRUE(boolEntry != allPolicyValue.end() && boolEntry->second == "true"); 182 183 res = policyMgr_->SetPolicy(TEST_ADMIN_NAME, TEST_BOOL_POLICY_NAME, "", ""); 184 ASSERT_TRUE(res == ERR_OK); 185 } 186 187 /** 188 * @tc.name: TestGetPolicyUserIds 189 * @tc.desc: Test PolicyManager GetPolicyUserIds func. 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(PolicyManagerTest, TestGetPolicyUserIds, TestSize.Level1) 193 { 194 std::vector<int32_t> userIds; 195 policyMgr_->GetPolicyUserIds(userIds); 196 ASSERT_TRUE(userIds.size() == 1); 197 ASSERT_TRUE(userIds[0] == TEST_USER_ID); 198 199 ASSERT_TRUE(policyMgr_->GetUserPolicyMgr(102) != nullptr); 200 201 userIds = {}; 202 policyMgr_->GetPolicyUserIds(userIds); 203 ASSERT_TRUE(userIds.size() == 2); 204 } 205 206 /** 207 * @tc.name: TestGetUserPolicyMgr 208 * @tc.desc: Test PolicyManager GetUserPolicyMgr func. 209 * @tc.type: FUNC 210 */ 211 HWTEST_F(PolicyManagerTest, TestGetUserPolicyMgr, TestSize.Level1) 212 { 213 ASSERT_TRUE(policyMgr_->GetUserPolicyMgr(DEFAULT_USERID) != nullptr); 214 ASSERT_TRUE(policyMgr_->GetUserPolicyMgr(TEST_USER_ID) != nullptr); 215 } 216 } // namespace TEST 217 } // namespace EDM 218 } // namespace OHOS 219