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