1 /*
2 * Copyright (c) 2022 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
18 #include "storage_daemon_client.h"
19 #include "ipc/istorage_daemon.h"
20 #include "storage_service_errno.h"
21 #include "storage_service_log.h"
22 #include "help_utils.h"
23 namespace OHOS {
24 namespace StorageDaemon {
25 using namespace testing::ext;
26
27 class StorageDaemonClientTest : public testing::Test {
28 public:
SetUpTestCase(void)29 static void SetUpTestCase(void) {};
TearDownTestCase(void)30 static void TearDownTestCase(void) {};
31 void SetUp();
32 void TearDown();
33
34 StorageDaemonClient* storageDaemonClient_;
35 };
36
SetUp()37 void StorageDaemonClientTest::SetUp()
38 {
39 storageDaemonClient_ = new StorageDaemonClient();
40 }
41
TearDown(void)42 void StorageDaemonClientTest::TearDown(void)
43 {
44 StorageTest::StorageTestUtils::ClearTestResource();
45 if (storageDaemonClient_ != nullptr) {
46 delete storageDaemonClient_;
47 storageDaemonClient_ = nullptr;
48 }
49 }
50
51 /**
52 * @tc.name: Storage_Service_StorageDaemonClientTest_PrepareUserDirs_001
53 * @tc.desc: Verify the PrepareUserDirs function when args are normal.
54 * @tc.type: FUNC
55 * @tc.require: AR000GK4HB
56 */
57 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_PrepareUserDirs_001, TestSize.Level1)
58 {
59 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_PrepareUserDirs_001 start";
60
61 ASSERT_TRUE(storageDaemonClient_ != nullptr);
62
63 int32_t userid = 103;
64 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
65 int32_t ret = storageDaemonClient_->PrepareUserDirs(userid, flags);
66 EXPECT_TRUE(ret == E_OK);
67
68 ret = storageDaemonClient_->DestroyUserDirs(userid, flags);
69 EXPECT_TRUE(ret == E_OK);
70 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_PrepareUserDirs_001 end";
71 }
72
73 /**
74 * @tc.name: Storage_Service_StorageDaemonClientTest_StartUser_001
75 * @tc.desc: check the StartUser function when args are normal
76 * @tc.type: FUNC
77 * @tc.require: AR000GK4HB
78 */
79 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_StartUser_001, TestSize.Level1)
80 {
81 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_StartUser_001 start";
82
83 ASSERT_TRUE(storageDaemonClient_ != nullptr);
84
85 int32_t userid = 104;
86 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
87 int32_t ret = storageDaemonClient_->PrepareUserDirs(userid, flags);
88 EXPECT_TRUE(ret == E_OK) << "PrepareUserDirs error";
89 ret = storageDaemonClient_->StartUser(userid);
90 EXPECT_TRUE(ret == E_OK) << "StartUser error";
91
92 ret = storageDaemonClient_->StopUser(userid);
93 EXPECT_TRUE(ret == E_OK) << "check StopUser error";
94
95 storageDaemonClient_->DestroyUserDirs(userid, flags);
96 EXPECT_TRUE(ret == E_OK);
97 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_StartUser_001 end";
98 }
99
100 /**
101 * @tc.name: Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001
102 * @tc.desc: Verify the PrepareUserSpace function when args are normal.
103 * @tc.type: FUNC
104 * @tc.require: AR000GK4HB
105 */
106 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001 start";
109
110 ASSERT_TRUE(storageDaemonClient_ != nullptr);
111
112 int32_t userid = 105;
113 std::string volId = "vol-1-1";
114 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
115 int32_t ret = storageDaemonClient_->PrepareUserSpace(userid, volId, flags);
116 EXPECT_TRUE(ret == E_OK);
117
118 storageDaemonClient_->DestroyUserSpace(userid, volId, flags);
119 EXPECT_TRUE(ret == E_OK);
120 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001 end";
121 }
122
123 /**
124 * @tc.name: Storage_Service_StorageDaemonClientTest_ActiveUserKey_001
125 * @tc.desc: Verify the ActiveUserKey function.
126 * @tc.type: FUNC
127 * @tc.require: AR000H0F7I
128 */
129 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_ActiveUserKey_001, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_ActiveUserKey_001 start";
132
133 ASSERT_TRUE(storageDaemonClient_ != nullptr);
134
135 int32_t userid = 108;
136 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
137 int32_t ret = storageDaemonClient_->GenerateUserKeys(userid, flags);
138 ASSERT_TRUE(ret == E_OK);
139
140 ret = storageDaemonClient_->ActiveUserKey(userid, {}, {});
141 EXPECT_TRUE(ret == E_OK);
142
143 ret = storageDaemonClient_->InactiveUserKey(userid);
144 EXPECT_TRUE(ret == E_OK);
145
146 storageDaemonClient_->DeleteUserKeys(userid);
147 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_ActiveUserKey_001 end";
148 }
149
150 /**
151 * @tc.name: Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001
152 * @tc.desc: Verify the UpdateUserAuth function.
153 * @tc.type: FUNC
154 * @tc.require: AR000H0F7I
155 */
156 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001, TestSize.Level1)
157 {
158 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001 start";
159
160 ASSERT_TRUE(storageDaemonClient_ != nullptr);
161
162 int32_t userid = 109;
163 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
164 int32_t ret = storageDaemonClient_->PrepareUserDirs(userid, flags);
165 ret = storageDaemonClient_->StartUser(userid);
166 EXPECT_TRUE(ret == E_OK) << "StartUser error";
167
168 ret = storageDaemonClient_->UpdateUserAuth(userid, 0, {}, {}, {});
169 EXPECT_TRUE(ret == E_OK) << "UpdateUserAuth error";
170
171 ret = storageDaemonClient_->StopUser(userid);
172 storageDaemonClient_->DestroyUserDirs(userid, flags);
173 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001 end";
174 }
175
176 /**
177 * @tc.name: Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001
178 * @tc.desc: Verify the UpdateKeyContext function.
179 * @tc.type: FUNC
180 * @tc.require: AR000H0F7I
181 */
182 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001, TestSize.Level1)
183 {
184 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001 start";
185
186 ASSERT_TRUE(storageDaemonClient_ != nullptr);
187
188 int32_t userid = 110;
189 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
190 int32_t ret = storageDaemonClient_->GenerateUserKeys(userid, flags);
191 ASSERT_TRUE(ret == E_OK);
192
193 ret = storageDaemonClient_->UpdateUserAuth(userid, 0, {}, {}, {});
194 EXPECT_TRUE(ret == E_OK) << "UpdateUserAuth error";
195
196 ret = storageDaemonClient_->UpdateKeyContext(userid);
197 EXPECT_TRUE(ret == E_OK);
198
199 storageDaemonClient_->DeleteUserKeys(userid);
200 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001 end";
201 }
202 }
203 }