1 /*
2 * Copyright (C) 2021-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 "deviceauth_standard_test.h"
17 #include <cinttypes>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include "account_module_defines.h"
21 #include "alg_loader.h"
22 #include "common_defs.h"
23 #include "device_auth.h"
24 #include "device_auth_defines.h"
25 #include "device_auth_ext.h"
26 #include "hc_dev_info_mock.h"
27 #include "json_utils_mock.h"
28 #include "json_utils.h"
29 #include "protocol_task_main_mock.h"
30 #include "securec.h"
31
32 using namespace std;
33 using namespace testing::ext;
34
35 namespace {
36 #define TEST_REQ_ID 123
37 #define TEST_REQ_ID2 321
38 #define TEST_REQ_ID3 132
39 #define TEST_REQ_ID4 213
40 #define TEST_APP_ID "TestAppId"
41 #define TEST_APP_ID2 "TestAppId2"
42 #define TEST_GROUP_NAME "TestGroup"
43 #define TEST_AUTH_ID "TestAuthId"
44 #define TEST_AUTH_ID2 "TestAuthId2"
45 #define TEST_AUTH_ID3 "TestAuthId3"
46 #define TEST_UDID "TestUdid"
47 #define TEST_UDID2 "TestUdid2"
48 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
49 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
50 #define TEST_USER_ID_AUTH "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
51 #define TEST_USER_ID "1234ABCD"
52 #define TEST_USER_ID2 "DCBA4321"
53 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
54 #define TEST_GROUP_ID2 "F2AA208B1E010542B20A34B03B4B6289EA7C7F6DFE97DA2E370348B826682D3D"
55 #define TEST_GROUP_ID3 "1234ABCD"
56 #define TEST_GROUP_ID4 "6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F"
57 #define TEST_AUTH_CODE "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b"
58 #define TEST_AUTH_CODE2 "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335"
59 #define TEST_AUTH_CODE3 "1234567812345678123456781234567812345678123456781234567812345678"
60 #define TEST_AUTH_TOKEN3 "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92"
61 #define TEST_QUERY_PARAMS "bac"
62 #define TEST_PIN_CODE "123456"
63 #define TEST_GROUP_DATA_PATH "/data/service/el1/public/deviceauthMock"
64 #define TEST_HKS_MAIN_DATA_PATH "/data/service/el1/public/huks_service/tmp/+0+0+0+0"
65 #define TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN 32
66 #define TEST_DEV_AUTH_SLEEP_TIME 50000
67 #define TEST_DEV_AUTH_SLEEP_TIME2 60000
68 static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
69 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
70 static const char *INVALID_JSON_STR = "invalid json format";
71 static const char *CREATE_PARAMS = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
72 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
73 static const char *ADD_PARAMS =
74 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
75 "\"groupType\":256,\"pinCode\":\"123456\"}";
76 static const char *DELETE_PARAMS =
77 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"TestAuthId2\"}";
78 static const char *DELETE_PARAMS4 =
79 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"Test"
80 "AuthId2\", \"isForceDelete\":true, \"isIgnoreChannel\":true}";
81
82 enum AsyncStatus {
83 ASYNC_STATUS_WAITING = 0,
84 ASYNC_STATUS_TRANSMIT = 1,
85 ASYNC_STATUS_FINISH = 2,
86 ASYNC_STATUS_ERROR = 3
87 };
88
89 static AsyncStatus volatile g_asyncStatus;
90 static uint32_t g_transmitDataMaxLen = 2048;
91 static uint8_t g_transmitData[2048] = { 0 };
92 static uint32_t g_transmitDataLen = 0;
93
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)94 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
95 {
96 if (memcpy_s(g_transmitData, g_transmitDataMaxLen, data, dataLen) != EOK) {
97 return false;
98 }
99 g_transmitDataLen = dataLen;
100 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
101 return true;
102 }
103
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)104 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
105 {
106 (void)requestId;
107 (void)sessionKey;
108 (void)sessionKeyLen;
109 return;
110 }
111
OnFinish(int64_t requestId,int operationCode,const char * authReturn)112 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
113 {
114 g_asyncStatus = ASYNC_STATUS_FINISH;
115 }
116
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)117 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
118 {
119 g_asyncStatus = ASYNC_STATUS_ERROR;
120 }
121
OnBindRequest(int64_t requestId,int operationCode,const char * reqParam)122 static char *OnBindRequest(int64_t requestId, int operationCode, const char* reqParam)
123 {
124 CJson *json = CreateJson();
125 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
126 AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
127 AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE);
128 AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID2);
129 char *returnDataStr = PackJsonToString(json);
130 FreeJson(json);
131 return returnDataStr;
132 }
133
134 static DeviceAuthCallback g_gmCallback = {
135 .onTransmit = OnTransmit,
136 .onSessionKeyReturned = OnSessionKeyReturned,
137 .onFinish = OnFinish,
138 .onError = OnError,
139 .onRequest = OnBindRequest
140 };
141
RemoveDir(const char * path)142 static void RemoveDir(const char *path)
143 {
144 char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = {0};
145 if (path == nullptr) {
146 return;
147 }
148 if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
149 return;
150 }
151 system(strBuf);
152 }
153
DeleteDatabase()154 static void DeleteDatabase()
155 {
156 RemoveDir(TEST_GROUP_DATA_PATH);
157 RemoveDir(TEST_HKS_MAIN_DATA_PATH);
158 }
159
CreateDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)160 static void CreateDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *createParams)
161 {
162 g_asyncStatus = ASYNC_STATUS_WAITING;
163 const DeviceGroupManager *gm = GetGmInstance();
164 int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
165 if (ret != HC_SUCCESS) {
166 g_asyncStatus = ASYNC_STATUS_ERROR;
167 return;
168 }
169 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
170 usleep(TEST_DEV_AUTH_SLEEP_TIME);
171 }
172 usleep(TEST_DEV_AUTH_SLEEP_TIME);
173 }
174
AddDemoMember(void)175 static void AddDemoMember(void)
176 {
177 g_asyncStatus = ASYNC_STATUS_WAITING;
178 bool isClient = true;
179 SetDeviceStatus(isClient);
180 const DeviceGroupManager *gm = GetGmInstance();
181 int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
182 if (ret != HC_SUCCESS) {
183 g_asyncStatus = ASYNC_STATUS_ERROR;
184 return;
185 }
186 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
187 usleep(TEST_DEV_AUTH_SLEEP_TIME);
188 }
189 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
190 isClient = !isClient;
191 SetDeviceStatus(isClient);
192 g_asyncStatus = ASYNC_STATUS_WAITING;
193 uint8_t tmpTransmitData[2048] = { 0 };
194 uint32_t tmpTransmitDataLen = 0;
195 if (memcpy_s(tmpTransmitData, sizeof(tmpTransmitData), g_transmitData, g_transmitDataLen) != EOK) {
196 g_asyncStatus = ASYNC_STATUS_ERROR;
197 return;
198 }
199 tmpTransmitDataLen = g_transmitDataLen;
200 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
201 g_transmitDataLen = 0;
202 if (isClient) {
203 ret = gm->processData(TEST_REQ_ID, tmpTransmitData, tmpTransmitDataLen);
204 } else {
205 ret = gm->processData(TEST_REQ_ID2, tmpTransmitData, tmpTransmitDataLen);
206 }
207 if (ret != HC_SUCCESS) {
208 g_asyncStatus = ASYNC_STATUS_ERROR;
209 return;
210 }
211 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
212 usleep(TEST_DEV_AUTH_SLEEP_TIME);
213 }
214 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
215 break;
216 }
217 if (g_transmitDataLen > 0) {
218 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
219 }
220 }
221 usleep(TEST_DEV_AUTH_SLEEP_TIME2);
222 SetDeviceStatus(true);
223 }
224
DeleteDemoMember(int32_t osAccountId,int64_t reqId,const char * appId,const char * deleteParams)225 static void DeleteDemoMember(int32_t osAccountId, int64_t reqId, const char *appId, const char *deleteParams)
226 {
227 g_asyncStatus = ASYNC_STATUS_WAITING;
228 bool isClient = true;
229 SetDeviceStatus(isClient);
230 const DeviceGroupManager *gm = GetGmInstance();
231 ASSERT_NE(gm, nullptr);
232 int32_t ret = gm->deleteMemberFromGroup(osAccountId, reqId, appId, deleteParams);
233 ASSERT_EQ(ret, HC_SUCCESS);
234 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
235 usleep(TEST_DEV_AUTH_SLEEP_TIME);
236 }
237 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
238 isClient = !isClient;
239 SetDeviceStatus(isClient);
240 g_asyncStatus = ASYNC_STATUS_WAITING;
241 if (isClient) {
242 ret = gm->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen);
243 } else {
244 ret = gm->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen);
245 }
246 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
247 g_transmitDataLen = 0;
248 ASSERT_EQ(ret, HC_SUCCESS);
249 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
250 usleep(TEST_DEV_AUTH_SLEEP_TIME);
251 }
252 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
253 break;
254 }
255 if (g_transmitDataLen > 0) {
256 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
257 }
258 }
259 SetDeviceStatus(true);
260 }
261
262 class GmAddMemberToGroupTest : public testing::Test {
263 public:
264 static void SetUpTestCase();
265 static void TearDownTestCase();
266 void SetUp();
267 void TearDown();
268 };
269
SetUpTestCase()270 void GmAddMemberToGroupTest::SetUpTestCase() {}
TearDownTestCase()271 void GmAddMemberToGroupTest::TearDownTestCase() {}
272
SetUp()273 void GmAddMemberToGroupTest::SetUp()
274 {
275 DeleteDatabase();
276 }
277
TearDown()278 void GmAddMemberToGroupTest::TearDown() {}
279
280 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest001, TestSize.Level0)
281 {
282 int32_t ret = InitDeviceAuthService();
283 EXPECT_EQ(ret, HC_SUCCESS);
284 const DeviceGroupManager *gm = GetGmInstance();
285 ASSERT_NE(gm, nullptr);
286 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
287 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
288 DestroyDeviceAuthService();
289 }
290
291 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest002, TestSize.Level0)
292 {
293 int32_t ret = InitDeviceAuthService();
294 EXPECT_EQ(ret, HC_SUCCESS);
295 const DeviceGroupManager *gm = GetGmInstance();
296 ASSERT_NE(gm, nullptr);
297 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
298 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
299 DestroyDeviceAuthService();
300 }
301
302 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest003, TestSize.Level0)
303 {
304 int32_t ret = InitDeviceAuthService();
305 EXPECT_EQ(ret, HC_SUCCESS);
306 const DeviceGroupManager *gm = GetGmInstance();
307 ASSERT_NE(gm, nullptr);
308 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
309 ASSERT_NE(ret, HC_SUCCESS);
310 DestroyDeviceAuthService();
311 }
312
313 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest004, TestSize.Level0)
314 {
315 int32_t ret = InitDeviceAuthService();
316 EXPECT_EQ(ret, HC_SUCCESS);
317 const DeviceGroupManager *gm = GetGmInstance();
318 ASSERT_NE(gm, nullptr);
319 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
320 ASSERT_EQ(ret, HC_SUCCESS);
321 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, INVALID_JSON_STR);
322 ASSERT_NE(ret, HC_SUCCESS);
323 DestroyDeviceAuthService();
324 }
325
326 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest005, TestSize.Level0)
327 {
328 SetIsoSupported(true);
329 SetPakeV1Supported(false);
330 int32_t ret = InitDeviceAuthService();
331 ASSERT_EQ(ret, HC_SUCCESS);
332 const DeviceGroupManager *gm = GetGmInstance();
333 ASSERT_NE(gm, nullptr);
334 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
335 ASSERT_EQ(ret, HC_SUCCESS);
336 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
337 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
338 AddDemoMember();
339 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
340 DestroyDeviceAuthService();
341 }
342
343 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest006, TestSize.Level0)
344 {
345 SetIsoSupported(false);
346 SetPakeV1Supported(true);
347 int32_t ret = InitDeviceAuthService();
348 ASSERT_EQ(ret, HC_SUCCESS);
349 const DeviceGroupManager *gm = GetGmInstance();
350 ASSERT_NE(gm, nullptr);
351 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
352 ASSERT_EQ(ret, HC_SUCCESS);
353 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
354 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
355 AddDemoMember();
356 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
357 DestroyDeviceAuthService();
358 }
359
360 class GmDeleteMemberFromGroupTest : public testing::Test {
361 public:
362 static void SetUpTestCase();
363 static void TearDownTestCase();
364 void SetUp();
365 void TearDown();
366 };
367
SetUpTestCase()368 void GmDeleteMemberFromGroupTest::SetUpTestCase() {}
TearDownTestCase()369 void GmDeleteMemberFromGroupTest::TearDownTestCase() {}
370
SetUp()371 void GmDeleteMemberFromGroupTest::SetUp()
372 {
373 DeleteDatabase();
374 }
375
TearDown()376 void GmDeleteMemberFromGroupTest::TearDown()
377 {
378 DestroyDeviceAuthService();
379 }
380
381 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest001, TestSize.Level0)
382 {
383 int32_t ret = InitDeviceAuthService();
384 ASSERT_EQ(ret, HC_SUCCESS);
385 const DeviceGroupManager *gm = GetGmInstance();
386 ASSERT_NE(gm, nullptr);
387 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
388 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
389 }
390
391 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest002, TestSize.Level0)
392 {
393 int32_t ret = InitDeviceAuthService();
394 ASSERT_EQ(ret, HC_SUCCESS);
395 const DeviceGroupManager *gm = GetGmInstance();
396 ASSERT_NE(gm, nullptr);
397 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
398 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
399 }
400
401 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest003, TestSize.Level0)
402 {
403 int32_t ret = InitDeviceAuthService();
404 ASSERT_EQ(ret, HC_SUCCESS);
405 const DeviceGroupManager *gm = GetGmInstance();
406 ASSERT_NE(gm, nullptr);
407 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS);
408 ASSERT_NE(ret, HC_SUCCESS);
409 }
410
411 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest004, TestSize.Level0)
412 {
413 int32_t ret = InitDeviceAuthService();
414 ASSERT_EQ(ret, HC_SUCCESS);
415 const DeviceGroupManager *gm = GetGmInstance();
416 ASSERT_NE(gm, nullptr);
417 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
418 ASSERT_EQ(ret, HC_SUCCESS);
419 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, INVALID_JSON_STR);
420 ASSERT_NE(ret, HC_SUCCESS);
421 }
422
423 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest005, TestSize.Level0)
424 {
425 SetIsoSupported(true);
426 SetPakeV1Supported(false);
427 int32_t ret = InitDeviceAuthService();
428 ASSERT_EQ(ret, HC_SUCCESS);
429 const DeviceGroupManager *gm = GetGmInstance();
430 ASSERT_NE(gm, nullptr);
431 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
432 ASSERT_EQ(ret, HC_SUCCESS);
433 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
434 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
435 AddDemoMember();
436 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
437 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS);
438 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
439 }
440
441 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest006, TestSize.Level0)
442 {
443 SetIsoSupported(false);
444 SetPakeV1Supported(true);
445 int32_t ret = InitDeviceAuthService();
446 ASSERT_EQ(ret, HC_SUCCESS);
447 const DeviceGroupManager *gm = GetGmInstance();
448 ASSERT_NE(gm, nullptr);
449 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
450 ASSERT_EQ(ret, HC_SUCCESS);
451 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
452 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
453 AddDemoMember();
454 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
455 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS);
456 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
457 }
458
459 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest007, TestSize.Level0)
460 {
461 SetIsoSupported(true);
462 SetPakeV1Supported(false);
463 int32_t ret = InitDeviceAuthService();
464 ASSERT_EQ(ret, HC_SUCCESS);
465 const DeviceGroupManager *gm = GetGmInstance();
466 ASSERT_NE(gm, nullptr);
467 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
468 ASSERT_EQ(ret, HC_SUCCESS);
469 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
470 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
471 AddDemoMember();
472 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
473 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS4);
474 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
475 }
476
477 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest008, TestSize.Level0)
478 {
479 SetIsoSupported(true);
480 SetPakeV1Supported(false);
481 int32_t ret = InitDeviceAuthService();
482 ASSERT_EQ(ret, HC_SUCCESS);
483 const DeviceGroupManager *gm = GetGmInstance();
484 ASSERT_NE(gm, nullptr);
485 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
486 ASSERT_EQ(ret, HC_SUCCESS);
487 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
488 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
489 AddDemoMember();
490 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
491 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS4);
492 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
493 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS4);
494 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
495 }
496
497 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest009, TestSize.Level0)
498 {
499 SetIsoSupported(true);
500 SetPakeV1Supported(false);
501 int32_t ret = InitDeviceAuthService();
502 ASSERT_EQ(ret, HC_SUCCESS);
503 const DeviceGroupManager *gm = GetGmInstance();
504 ASSERT_NE(gm, nullptr);
505 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
506 ASSERT_EQ(ret, HC_SUCCESS);
507 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
508 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
509 AddDemoMember();
510 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
511 const char *deleteParams = "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C28"
512 "74C230C7C21\",\"deleteId\":\"InvalidAuthId\", \"isForceDelete\":true, \"isIgnoreChannel\":true}";
513 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, deleteParams);
514 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
515 }
516
517 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest010, TestSize.Level0)
518 {
519 SetIsoSupported(true);
520 SetPakeV1Supported(false);
521 int32_t ret = InitDeviceAuthService();
522 ASSERT_EQ(ret, HC_SUCCESS);
523 const DeviceGroupManager *gm = GetGmInstance();
524 ASSERT_NE(gm, nullptr);
525 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
526 ASSERT_EQ(ret, HC_SUCCESS);
527 const char *deleteParams = "{\"deleteId\":\"TestAuthId2\", \"isForceDelete\":true, \"isIgnoreChannel\":true}";
528 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, deleteParams);
529 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
530 }
531
532 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest011, TestSize.Level0)
533 {
534 SetIsoSupported(true);
535 SetPakeV1Supported(false);
536 int32_t ret = InitDeviceAuthService();
537 ASSERT_EQ(ret, HC_SUCCESS);
538 const DeviceGroupManager *gm = GetGmInstance();
539 ASSERT_NE(gm, nullptr);
540 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
541 ASSERT_EQ(ret, HC_SUCCESS);
542 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
543 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
544 AddDemoMember();
545 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
546 const char *deleteParams = "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C28"
547 "74C230C7C21\",\"isForceDelete\":true, \"isIgnoreChannel\":true}";
548 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, deleteParams);
549 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
550 }
551 }
552