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