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 "UTTest_mine_hichain_connector.h"
17
18 #include "dm_anonymous.h"
19 #include "dm_constants.h"
20 #include "mine_hichain_connector.h"
21
22 namespace OHOS {
23 namespace DistributedHardware {
SetUp()24 void MiniHiChainAuthConnectorTest::SetUp()
25 {
26 }
27
TearDown()28 void MiniHiChainAuthConnectorTest::TearDown()
29 {
30 }
31
SetUpTestCase()32 void MiniHiChainAuthConnectorTest::SetUpTestCase()
33 {
34 }
35
TearDownTestCase()36 void MiniHiChainAuthConnectorTest::TearDownTestCase()
37 {
38 }
39
40 HWTEST_F(MiniHiChainAuthConnectorTest, onFinish_001, testing::ext::TestSize.Level0)
41 {
42 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
43 int64_t requestId = 159357462;
44 int operationCode = 0;
45 char *returnData = nullptr;
46 minHiChain->onFinish(requestId, operationCode, returnData);
47 EXPECT_EQ(minHiChain->IsCredentialExist(), false);
48 }
49
50 HWTEST_F(MiniHiChainAuthConnectorTest, onFinish_002, testing::ext::TestSize.Level0)
51 {
52 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
53 int64_t requestId = 0;
54 int operationCode = 0;
55 char *returnData = nullptr;
56 minHiChain->onFinish(requestId, operationCode, returnData);
57 EXPECT_EQ(minHiChain->IsCredentialExist(), false);
58 }
59
60 HWTEST_F(MiniHiChainAuthConnectorTest, onError_001, testing::ext::TestSize.Level0)
61 {
62 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
63 int64_t requestId = 159357462;
64 int operationCode = 0;
65 int errorCode = 0;
66 char *returnData = nullptr;
67 minHiChain->onError(requestId, operationCode, errorCode, returnData);
68 EXPECT_EQ(minHiChain->IsCredentialExist(), false);
69 }
70
71 HWTEST_F(MiniHiChainAuthConnectorTest, onError_002, testing::ext::TestSize.Level0)
72 {
73 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
74 int64_t requestId = 0;
75 int operationCode = 0;
76 int errorCode = 0;
77 char *returnData = nullptr;
78 minHiChain->onError(requestId, operationCode, errorCode, returnData);
79 EXPECT_EQ(minHiChain->IsCredentialExist(), false);
80 }
81
82 HWTEST_F(MiniHiChainAuthConnectorTest, Init_001, testing::ext::TestSize.Level0)
83 {
84 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
85 int32_t ret = minHiChain->Init();
86 EXPECT_EQ(ret, DM_OK);
87 }
88
89 HWTEST_F(MiniHiChainAuthConnectorTest, UnInit_001, testing::ext::TestSize.Level0)
90 {
91 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
92 int32_t ret = minHiChain->Init();
93 EXPECT_EQ(ret, DM_OK);
94 }
95
96 HWTEST_F(MiniHiChainAuthConnectorTest, DeleteCredentialAndGroup_001, testing::ext::TestSize.Level0)
97 {
98 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
99 int32_t ret = minHiChain->DeleteCredentialAndGroup();
100 EXPECT_EQ(ret, DM_OK);
101 }
102
103 HWTEST_F(MiniHiChainAuthConnectorTest, CreateGroup_001, testing::ext::TestSize.Level0)
104 {
105 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
106 std::string reqJsonStr;
107 int32_t ret = minHiChain->CreateGroup(reqJsonStr);
108 EXPECT_EQ(ret, ERR_DM_FAILED);
109 }
110
111 HWTEST_F(MiniHiChainAuthConnectorTest, CreateGroup_002, testing::ext::TestSize.Level0)
112 {
113 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
114 JsonObject jsonObject;
115 jsonObject["userId"] = 123456789;
116 std::string reqJsonStr = SafetyDump(jsonObject);
117 int32_t ret = minHiChain->CreateGroup(reqJsonStr);
118 EXPECT_EQ(ret, ERR_DM_FAILED);
119 }
120
121 HWTEST_F(MiniHiChainAuthConnectorTest, CreateGroup_003, testing::ext::TestSize.Level0)
122 {
123 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
124 JsonObject jsonObject;
125 jsonObject["userId"] = "123456789";
126 std::string reqJsonStr = SafetyDump(jsonObject);
127 int32_t ret = minHiChain->CreateGroup(reqJsonStr);
128 EXPECT_EQ(ret, ERR_DM_FAILED);
129 }
130
131 HWTEST_F(MiniHiChainAuthConnectorTest, RequestCredential_001, testing::ext::TestSize.Level0)
132 {
133 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
134 JsonObject jsonObject;
135 jsonObject["userId"] = "123456789";
136 std::string returnJsonStr = SafetyDump(jsonObject);
137 int32_t ret = minHiChain->RequestCredential(returnJsonStr);
138 EXPECT_EQ(ret, DM_OK);
139 }
140
141 HWTEST_F(MiniHiChainAuthConnectorTest, CheckCredential_001, testing::ext::TestSize.Level0)
142 {
143 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
144 std::string reqJsonStr;
145 std::string returnJsonStr;
146 int32_t ret = minHiChain->CheckCredential(reqJsonStr, returnJsonStr);
147 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
148 }
149
150 HWTEST_F(MiniHiChainAuthConnectorTest, CheckCredential_002, testing::ext::TestSize.Level0)
151 {
152 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
153 std::string reqJsonStr = "reqJsonStr";
154 std::string returnJsonStr;
155 int32_t ret = minHiChain->CheckCredential(reqJsonStr, returnJsonStr);
156 EXPECT_EQ(ret, DM_OK);
157 }
158
159 HWTEST_F(MiniHiChainAuthConnectorTest, ImportCredential_001, testing::ext::TestSize.Level0)
160 {
161 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
162 std::string reqJsonStr;
163 std::string returnJsonStr;
164 int32_t ret = minHiChain->ImportCredential(reqJsonStr, returnJsonStr);
165 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
166 }
167
168 HWTEST_F(MiniHiChainAuthConnectorTest, ImportCredential_002, testing::ext::TestSize.Level0)
169 {
170 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
171 JsonObject jsonObject;
172 jsonObject["userId"] = 123456789;
173 std::string reqJsonStr = SafetyDump(jsonObject);
174 std::string returnJsonStr;
175 int32_t ret = minHiChain->ImportCredential(reqJsonStr, returnJsonStr);
176 EXPECT_EQ(ret, ERR_DM_HICHAIN_REGISTER_CALLBACK);
177 }
178
179 HWTEST_F(MiniHiChainAuthConnectorTest, DeleteCredential_001, testing::ext::TestSize.Level0)
180 {
181 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
182 std::string reqJsonStr;
183 std::string returnJsonStr;
184 int32_t ret = minHiChain->DeleteCredential(reqJsonStr, returnJsonStr);
185 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
186 }
187
188 HWTEST_F(MiniHiChainAuthConnectorTest, DeleteCredential_002, testing::ext::TestSize.Level0)
189 {
190 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
191 std::string reqJsonStr = "reqJsonStr";
192 std::string returnJsonStr;
193 int32_t ret = minHiChain->DeleteCredential(reqJsonStr, returnJsonStr);
194 EXPECT_EQ(ret, DM_OK);
195 }
196
197 HWTEST_F(MiniHiChainAuthConnectorTest, IsCredentialExist_001, testing::ext::TestSize.Level0)
198 {
199 std::shared_ptr<MineHiChainConnector> minHiChain = std::make_shared<MineHiChainConnector>();
200 bool ret = minHiChain->IsCredentialExist();
201 EXPECT_EQ(ret, false);
202 }
203 } // namespace DistributedHardware
204 } // namespace OHOS
205