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 
16 #include <gtest/gtest.h>
17 #include <unistd.h>
18 
19 #include "accesstoken_kit.h"
20 #include "cloud_manager.h"
21 #include "logger.h"
22 #include "token_setproc.h"
23 
24 namespace OHOS::CloudData {
25 using namespace testing::ext;
26 using namespace OHOS::Security::AccessToken;
27 using namespace OHOS::Rdb;
28 uint64_t g_selfTokenID = 0;
29 static constexpr const char *TEST_BUNDLE_NAME = "bundleName";
30 static constexpr const char *TEST_ACCOUNT_ID = "testId";
31 static constexpr const char *TEST_STORE_ID = "storeId";
AllocSystemHapToken(const HapPolicyParams & policy)32 void AllocSystemHapToken(const HapPolicyParams &policy)
33 {
34     HapInfoParams info = {
35         .userID = 100,
36         .bundleName = "ohos.clouddatatest.demo",
37         .instIndex = 0,
38         .appIDDesc = "ohos.clouddatatest.demo",
39         .isSystemApp = true
40     };
41     auto token = AccessTokenKit::AllocHapToken(info, policy);
42     SetSelfTokenID(token.tokenIDEx);
43 }
44 
AllocNormalHapToken(const HapPolicyParams & policy)45 void AllocNormalHapToken(const HapPolicyParams &policy)
46 {
47     HapInfoParams info = {
48         .userID = 100,
49         .bundleName = "ohos.clouddatatest.demo",
50         .instIndex = 0,
51         .appIDDesc = "ohos.clouddatatest.demo",
52         .isSystemApp = false
53     };
54     auto token = AccessTokenKit::AllocHapToken(info, policy);
55     SetSelfTokenID(token.tokenIDEx);
56 }
57 
58 HapPolicyParams g_normalPolicy = {
59     .apl = APL_NORMAL,
60     .domain = "test.domain",
61     .permList = {
62         {
63             .permissionName = "ohos.permission.CLOUDDATA_CONFIG",
64             .bundleName = "ohos.clouddatatest.demo",
65             .grantMode = 1,
66             .availableLevel = APL_NORMAL,
67             .label = "label",
68             .labelId = 1,
69             .description = "ohos.clouddatatest.demo",
70             .descriptionId = 1
71         }
72     },
73     .permStateList = {
74         {
75             .permissionName = "ohos.permission.CLOUDDATA_CONFIG",
76             .isGeneral = true,
77             .resDeviceID = { "local" },
78             .grantStatus = { PermissionState::PERMISSION_GRANTED },
79             .grantFlags = { 1 }
80         }
81     }
82 };
83 
84 HapPolicyParams g_systemPolicy = {
85     .apl = APL_SYSTEM_BASIC,
86     .domain = "test.domain",
87     .permList = {
88         {
89             .permissionName = "ohos.permission.CLOUDDATA_CONFIG",
90             .bundleName = "ohos.clouddatatest.demo",
91             .grantMode = 1,
92             .availableLevel = APL_SYSTEM_BASIC,
93             .label = "label",
94             .labelId = 1,
95             .description = "ohos.clouddatatest.demo",
96             .descriptionId = 1
97         }
98     },
99     .permStateList = {
100         {
101             .permissionName = "ohos.permission.CLOUDDATA_CONFIG",
102             .isGeneral = true,
103             .resDeviceID = { "local" },
104             .grantStatus = { PermissionState::PERMISSION_GRANTED },
105             .grantFlags = { 1 }
106         }
107     }
108 };
109 
110 HapPolicyParams g_notPermissonPolicy = {
111     .apl = APL_SYSTEM_BASIC,
112     .domain = "test.domain",
113     .permList = {
114         {
115             .permissionName = "ohos.permission.TEST",
116             .bundleName = "ohos.clouddatatest.demo",
117             .grantMode = 1,
118             .availableLevel = APL_SYSTEM_BASIC,
119             .label = "label",
120             .labelId = 1,
121             .description = "ohos.clouddatatest.demo",
122             .descriptionId = 1
123         }
124     },
125     .permStateList = {
126         {
127             .permissionName = "ohos.permission.TEST",
128             .isGeneral = true,
129             .resDeviceID = { "local" },
130             .grantStatus = { PermissionState::PERMISSION_GRANTED },
131             .grantFlags = { 1 }
132         }
133     }
134 };
135 
136 class CloudDataTest : public testing::Test {
137 public:
138     static void SetUpTestCase(void);
139     static void TearDownTestCase(void);
SetUp()140     void SetUp()
141     {
142     }
TearDown()143     void TearDown()
144     {
145         SetSelfTokenID(g_selfTokenID);
146     }
147 };
148 
SetUpTestCase(void)149 void CloudDataTest::SetUpTestCase(void)
150 {
151     g_selfTokenID = GetSelfTokenID();
152 }
153 
TearDownTestCase(void)154 void CloudDataTest::TearDownTestCase(void)
155 {
156     SetSelfTokenID(g_selfTokenID);
157 }
158 
159 /* *
160  * @tc.name: CloudDataTest_001
161  * @tc.desc: Test the system application permissions of the QueryStatistics API
162  * @tc.type: FUNC
163  * @tc.require:
164  */
165 HWTEST_F(CloudDataTest, CloudDataTest_001, TestSize.Level0)
166 {
167     AllocNormalHapToken(g_normalPolicy);
168     auto [state, proxy] = CloudManager::GetInstance().GetCloudService();
169     if (state != CloudService::SUCCESS) {
170         EXPECT_TRUE(false);
171     } else {
172         auto [status, info] = proxy->QueryStatistics(TEST_ACCOUNT_ID, TEST_BUNDLE_NAME, TEST_STORE_ID);
173         EXPECT_EQ(status, CloudService::PERMISSION_DENIED);
174         EXPECT_TRUE(info.empty());
175     }
176 }
177 
178 /* *
179  * @tc.name: CloudDataTest_002
180  * @tc.desc: Test the permissions of the QueryStatistics API
181  * @tc.type: FUNC
182  * @tc.require:
183  */
184 HWTEST_F(CloudDataTest, CloudDataTest_002, TestSize.Level0)
185 {
186     AllocSystemHapToken(g_notPermissonPolicy);
187     auto [state, proxy] = CloudManager::GetInstance().GetCloudService();
188     if (state != CloudService::SUCCESS) {
189         EXPECT_TRUE(false);
190     } else {
191         auto [status, info] = proxy->QueryStatistics(TEST_ACCOUNT_ID, TEST_BUNDLE_NAME, TEST_STORE_ID);
192         EXPECT_EQ(status, CloudService::CLOUD_CONFIG_PERMISSION_DENIED);
193         EXPECT_TRUE(info.empty());
194     }
195 }
196 
197 /* *
198  * @tc.name: CloudDataTest_003
199  * @tc.desc: Test the permissions of the QueryStatistics API
200  * @tc.type: FUNC
201  * @tc.require:
202  */
203 HWTEST_F(CloudDataTest, CloudDataTest_003, TestSize.Level0)
204 {
205     AllocSystemHapToken(g_systemPolicy);
206     auto [state, proxy] = CloudManager::GetInstance().GetCloudService();
207     if (state != CloudService::SUCCESS) {
208         EXPECT_TRUE(false);
209     } else {
210         auto [status, info] = proxy->QueryStatistics(TEST_ACCOUNT_ID, TEST_BUNDLE_NAME, TEST_STORE_ID);
211         EXPECT_EQ(status, CloudService::ERROR);
212         EXPECT_TRUE(info.empty());
213     }
214 }
215 
216 /* *
217  * @tc.name: QueryLastSyncInfo001
218  * @tc.desc: Test the system application permissions of the QueryLastSyncInfo API
219  * @tc.type: FUNC
220  * @tc.require:
221  */
222 HWTEST_F(CloudDataTest, QueryLastSyncInfo001, TestSize.Level0)
223 {
224     AllocNormalHapToken(g_normalPolicy);
225     auto [state, proxy] = CloudManager::GetInstance().GetCloudService();
226     if (state != CloudService::SUCCESS) {
227         EXPECT_TRUE(false);
228     } else {
229         auto [status, info] = proxy->QueryLastSyncInfo(TEST_ACCOUNT_ID, TEST_BUNDLE_NAME, TEST_STORE_ID);
230         EXPECT_EQ(status, CloudService::PERMISSION_DENIED);
231         EXPECT_TRUE(info.empty());
232     }
233 }
234 
235 /* *
236  * @tc.name: QueryLastSyncInfo002
237  * @tc.desc: Test the permission name of the QueryLastSyncInfo API
238  * @tc.type: FUNC
239  * @tc.require:
240  */
241 HWTEST_F(CloudDataTest, QueryLastSyncInfo002, TestSize.Level0)
242 {
243     AllocSystemHapToken(g_notPermissonPolicy);
244     auto [state, proxy] = CloudManager::GetInstance().GetCloudService();
245     if (state != CloudService::SUCCESS) {
246         EXPECT_TRUE(false);
247     } else {
248         auto [status, info] = proxy->QueryLastSyncInfo(TEST_ACCOUNT_ID, TEST_BUNDLE_NAME, TEST_STORE_ID);
249         EXPECT_EQ(status, CloudService::CLOUD_CONFIG_PERMISSION_DENIED);
250         EXPECT_TRUE(info.empty());
251     }
252 }
253 } // namespace OHOS::CloudData