1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
16
17 #include "password_policy_serializer.h"
18 #include "password_policy_serializer_test.h"
19 #include "utils.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace EDM {
25 namespace TEST {
26 const std::string TEST_POLICY_DATA_ILEEGAL = "{\"complexityReg\":\"^(?=.*[a-zA-Z]).{1,9}$\", \"validityPeriod\": 2}";
27 const std::string TEST_POLICY_DATA = "{\"complexityReg\":\"^(?=.*[a-zA-Z]).{1,9}$\", \"validityPeriod\": 2,"
28 "\"additionalDescription\": \"testDescription\"}";
29 const std::string TEST_VALUE_COMPLEXITYREG = "^(?=.*[a-zA-Z]).{1,9}$";
30 const int TEST_VALUE_VALIDITY_PERIOD = 2;
31 const std::string TEST_VALUE_ADDITIONAL_DESCRIPTION = "testDescription";
SetUpTestSuite(void)32 void PasswordPolicySerializerTest::SetUpTestSuite(void)
33 {
34 Utils::SetEdmInitialEnv();
35 }
36
TearDownTestSuite(void)37 void PasswordPolicySerializerTest::TearDownTestSuite(void)
38 {
39 Utils::ResetTokenTypeAndUid();
40 ASSERT_TRUE(Utils::IsOriginalUTEnv());
41 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
42 }
43
44 /**
45 * @tc.name: TestDeserializeEmpty
46 * @tc.desc: Test PasswordSerializer::Deserialize when jsonString is empty
47 * @tc.type: FUNC
48 */
49 HWTEST_F(PasswordPolicySerializerTest, TestDeserializeEmpty, TestSize.Level1)
50 {
51 auto serializer = PasswordSerializer::GetInstance();
52 std::string jsonString;
53 PasswordPolicy policy;
54 bool ret = serializer->Deserialize(jsonString, policy);
55 ASSERT_TRUE(ret);
56 ASSERT_TRUE(policy.complexityReg.empty());
57 ASSERT_TRUE(policy.validityPeriod == 0);
58 ASSERT_TRUE(policy.additionalDescription.empty());
59 }
60
61 /**
62 * @tc.name: TestDeserializeIllegal
63 * @tc.desc: Test PasswordSerializer::Deserialize when jsonString is illegal
64 * @tc.type: FUNC
65 */
66 HWTEST_F(PasswordPolicySerializerTest, TestDeserializeIllegal, TestSize.Level1)
67 {
68 auto serializer = PasswordSerializer::GetInstance();
69 std::string jsonString = "{123";
70 PasswordPolicy policy;
71 bool ret = serializer->Deserialize(jsonString, policy);
72 ASSERT_FALSE(ret);
73 ASSERT_TRUE(policy.complexityReg.empty());
74 ASSERT_TRUE(policy.validityPeriod == 0);
75 ASSERT_TRUE(policy.additionalDescription.empty());
76 }
77
78 /**
79 * @tc.name: TestDeserializeIllegal2
80 * @tc.desc: Test PasswordSerializer::Deserialize when jsonString is illegal
81 * @tc.type: FUNC
82 */
83 HWTEST_F(PasswordPolicySerializerTest, TestDeserializeIllegal2, TestSize.Level1)
84 {
85 auto serializer = PasswordSerializer::GetInstance();
86 std::string jsonString = TEST_POLICY_DATA_ILEEGAL;
87 PasswordPolicy policy;
88 bool ret = serializer->Deserialize(jsonString, policy);
89 ASSERT_FALSE(ret);
90 ASSERT_TRUE(policy.complexityReg.empty());
91 ASSERT_TRUE(policy.validityPeriod == 0);
92 ASSERT_TRUE(policy.additionalDescription.empty());
93 }
94
95 /**
96 * @tc.name: TestDeserializeSuc
97 * @tc.desc: Test PasswordSerializer::Deserialize
98 * @tc.type: FUNC
99 */
100 HWTEST_F(PasswordPolicySerializerTest, TestDeserializeSuc, TestSize.Level1)
101 {
102 auto serializer = PasswordSerializer::GetInstance();
103 std::string jsonString = TEST_POLICY_DATA;
104 PasswordPolicy policy;
105 bool ret = serializer->Deserialize(jsonString, policy);
106 ASSERT_TRUE(ret);
107 ASSERT_TRUE(policy.complexityReg == TEST_VALUE_COMPLEXITYREG);
108 ASSERT_TRUE(policy.validityPeriod == TEST_VALUE_VALIDITY_PERIOD);
109 ASSERT_TRUE(policy.additionalDescription == TEST_VALUE_ADDITIONAL_DESCRIPTION);
110 }
111
112 /**
113 * @tc.name: TestSerializeSuc
114 * @tc.desc: Test PasswordSerializer::Serialize
115 * @tc.type: FUNC
116 */
117 HWTEST_F(PasswordPolicySerializerTest, TestSerializeSuc, TestSize.Level1)
118 {
119 auto serializer = PasswordSerializer::GetInstance();
120 std::string jsonString;
121 PasswordPolicy policy{TEST_VALUE_COMPLEXITYREG, TEST_VALUE_VALIDITY_PERIOD, TEST_VALUE_ADDITIONAL_DESCRIPTION};
122 bool ret = serializer->Serialize(policy, jsonString);
123 ASSERT_TRUE(ret);
124 ASSERT_FALSE(jsonString.empty());
125 }
126
127 /**
128 * @tc.name: TestGetPolicySuc
129 * @tc.desc: Test PasswordSerializer::GetPolicy
130 * @tc.type: FUNC
131 */
132 HWTEST_F(PasswordPolicySerializerTest, TestGetPolicySuc, TestSize.Level1)
133 {
134 auto serializer = PasswordSerializer::GetInstance();
135 MessageParcel data;
136 PasswordPolicy policy;
137 data.WriteString(TEST_VALUE_COMPLEXITYREG);
138 data.WriteInt64(TEST_VALUE_VALIDITY_PERIOD);
139 data.WriteString(TEST_VALUE_ADDITIONAL_DESCRIPTION);
140 bool ret = serializer->GetPolicy(data, policy);
141 ASSERT_TRUE(ret);
142 ASSERT_TRUE(policy.complexityReg == TEST_VALUE_COMPLEXITYREG);
143 ASSERT_TRUE(policy.validityPeriod == TEST_VALUE_VALIDITY_PERIOD);
144 ASSERT_TRUE(policy.additionalDescription == TEST_VALUE_ADDITIONAL_DESCRIPTION);
145 }
146
147 /**
148 * @tc.name: TestWritePolicySuc
149 * @tc.desc: Test PasswordSerializer::WritePolicy
150 * @tc.type: FUNC
151 */
152 HWTEST_F(PasswordPolicySerializerTest, TestWritePolicySuc, TestSize.Level1)
153 {
154 auto serializer = PasswordSerializer::GetInstance();
155 MessageParcel reply;
156 PasswordPolicy policy;
157 bool ret = serializer->WritePolicy(reply, policy);
158 ASSERT_TRUE(ret);
159 }
160
161 /**
162 * @tc.name: TestMergePolicyFail
163 * @tc.desc: Test PasswordSerializer::MergePolicy
164 * @tc.type: FUNC
165 */
166 HWTEST_F(PasswordPolicySerializerTest, TestMergePolicyFail, TestSize.Level1)
167 {
168 auto serializer = PasswordSerializer::GetInstance();
169 std::vector<PasswordPolicy> data;
170 PasswordPolicy policy;
171 bool ret = serializer->MergePolicy(data, policy);
172 ASSERT_FALSE(ret);
173 }
174
175 /**
176 * @tc.name: TestMergePolicySuc
177 * @tc.desc: Test PasswordSerializer::MergePolicy
178 * @tc.type: FUNC
179 */
180 HWTEST_F(PasswordPolicySerializerTest, TestMergePolicySuc, TestSize.Level1)
181 {
182 auto serializer = PasswordSerializer::GetInstance();
183 std::vector<PasswordPolicy> data;
184 PasswordPolicy policy;
185 data.push_back(policy);
186 bool ret = serializer->MergePolicy(data, policy);
187 ASSERT_TRUE(ret);
188 }
189
190 } // namespace TEST
191 } // namespace EDM
192 } // namespace OHOS
193