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 = StorageTest::USER_ID1;
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 = StorageTest::USER_ID2;
86 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
87 storageDaemonClient_->DestroyUserDirs(userid, flags);
88 int32_t ret = storageDaemonClient_->PrepareUserDirs(userid, flags);
89 EXPECT_TRUE(ret == E_OK) << "PrepareUserDirs error";
90 ret = storageDaemonClient_->StartUser(userid);
91 EXPECT_TRUE(ret == E_OK) << "StartUser error";
92
93 storageDaemonClient_->StopUser(userid);
94 storageDaemonClient_->DestroyUserDirs(userid, flags);
95 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_StartUser_001 end";
96 }
97
98 /**
99 * @tc.name: Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001
100 * @tc.desc: Verify the PrepareUserSpace function when args are normal.
101 * @tc.type: FUNC
102 * @tc.require: AR000GK4HB
103 */
104 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001, TestSize.Level1)
105 {
106 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001 start";
107
108 ASSERT_TRUE(storageDaemonClient_ != nullptr);
109
110 int32_t userid = StorageTest::USER_ID3;
111 std::string volId = "vol-1-1";
112 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
113 int32_t ret = storageDaemonClient_->PrepareUserSpace(userid, volId, flags);
114 EXPECT_TRUE(ret == E_OK);
115
116 storageDaemonClient_->DestroyUserSpace(userid, volId, flags);
117 EXPECT_TRUE(ret == E_OK);
118 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_PrepareUserSpace_001 end";
119 }
120
121 /**
122 * @tc.name: Storage_Service_StorageDaemonClientTest_MountDfsDocs_001
123 * @tc.desc: Verify the MountDfsDocs function when args are normal.
124 * @tc.type: FUNC
125 * @tc.require: issueI9G5A0
126 */
127 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_MountDfsDocs_001, TestSize.Level1)
128 {
129 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_MountDfsDocs_001 start";
130
131 ASSERT_TRUE(storageDaemonClient_ != nullptr);
132
133 int32_t userId = StorageTest::USER_ID3;
134 std::string relativePath = "account";
135 std::string networkId = "testnetworkid";
136 std::string deviceId = "testdevid";
137 int32_t ret = storageDaemonClient_->MountDfsDocs(userId, relativePath, networkId, deviceId);
138 EXPECT_EQ(ret, E_OK);
139 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_MountDfsDocs_001 end";
140 }
141
142 /**
143 * @tc.name: Storage_Service_StorageDaemonClientTest_UMountDfsDocs_001
144 * @tc.desc: Verify the UMountDfsDocs function when args are normal.
145 * @tc.type: FUNC
146 * @tc.require: issueI9G5A0
147 */
148 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_UMountDfsDocs_001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UMountDfsDocs_001 start";
151
152 ASSERT_TRUE(storageDaemonClient_ != nullptr);
153
154 int32_t userId = StorageTest::USER_ID3;
155 std::string relativePath = "account";
156 std::string networkId = "testnetworkid";
157 std::string deviceId = "testdevid";
158 int32_t ret = storageDaemonClient_->UMountDfsDocs(userId, relativePath, networkId, deviceId);
159 EXPECT_EQ(ret, E_OK);
160 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UMountDfsDocs_001 end";
161 }
162
163 /**
164 * @tc.name: Storage_Service_StorageDaemonClientTest_ActiveUserKey_001
165 * @tc.desc: Verify the ActiveUserKey function.
166 * @tc.type: FUNC
167 * @tc.require: AR000H0F7I
168 */
169 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_ActiveUserKey_001, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_ActiveUserKey_001 start";
172
173 ASSERT_TRUE(storageDaemonClient_ != nullptr);
174
175 int32_t userid = StorageTest::USER_ID4;
176 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
177 int32_t ret = storageDaemonClient_->GenerateUserKeys(userid, flags);
178 ASSERT_TRUE(ret == E_OK);
179
180 ret = storageDaemonClient_->ActiveUserKey(userid, {}, {});
181 EXPECT_TRUE(ret == E_OK);
182
183 ret = storageDaemonClient_->InactiveUserKey(userid);
184 EXPECT_TRUE(ret == E_OK);
185
186 storageDaemonClient_->DeleteUserKeys(userid);
187 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_ActiveUserKey_001 end";
188 }
189
190 /**
191 * @tc.name: Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001
192 * @tc.desc: Verify the UpdateUserAuth function.
193 * @tc.type: FUNC
194 * @tc.require: AR000H0F7I
195 */
196 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001, TestSize.Level1)
197 {
198 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001 start";
199
200 ASSERT_TRUE(storageDaemonClient_ != nullptr);
201
202 int32_t userid = StorageTest::USER_ID5;
203 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
204 int32_t ret = storageDaemonClient_->PrepareUserDirs(userid, flags);
205 ret = storageDaemonClient_->StartUser(userid);
206 EXPECT_TRUE(ret == E_OK) << "StartUser error";
207
208 ret = storageDaemonClient_->UpdateUserAuth(userid, 0, {}, {}, {});
209 EXPECT_TRUE(ret == E_OK) << "UpdateUserAuth error";
210
211 storageDaemonClient_->StopUser(userid);
212 storageDaemonClient_->DestroyUserDirs(userid, flags);
213 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateUserAuth_001 end";
214 }
215
216 /**
217 * @tc.name: Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001
218 * @tc.desc: Verify the UpdateKeyContext function.
219 * @tc.type: FUNC
220 * @tc.require: AR000H0F7I
221 */
222 HWTEST_F(StorageDaemonClientTest, Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001, TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001 start";
225
226 ASSERT_TRUE(storageDaemonClient_ != nullptr);
227
228 int32_t userid = StorageTest::USER_ID1;
229 int32_t flags = IStorageDaemon::CRYPTO_FLAG_EL2;
230 int32_t ret = storageDaemonClient_->GenerateUserKeys(userid, flags);
231 ASSERT_TRUE(ret == E_OK);
232
233 ret = storageDaemonClient_->UpdateUserAuth(userid, 0, {}, {}, {});
234 EXPECT_TRUE(ret == E_OK) << "UpdateUserAuth error";
235
236 ret = storageDaemonClient_->UpdateKeyContext(userid);
237 EXPECT_TRUE(ret == E_OK);
238
239 storageDaemonClient_->DeleteUserKeys(userid);
240 GTEST_LOG_(INFO) << "Storage_Service_StorageDaemonClientTest_UpdateKeyContext_001 end";
241 }
242 }
243 }