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_discovery_manager.h"
17
18#include <iostream>
19#include <string>
20#include <unistd.h>
21
22#include "device_manager_service_listener.h"
23#include "dm_anonymous.h"
24#include "dm_constants.h"
25#include "dm_log.h"
26#include "ipc_server_listener.h"
27#include "softbus_bus_center.h"
28#include "softbus_error_code.h"
29
30namespace OHOS {
31namespace DistributedHardware {
32void DiscoveryManagerTest::SetUp()
33{
34}
35
36void DiscoveryManagerTest::TearDown()
37{
38}
39
40void DiscoveryManagerTest::SetUpTestCase()
41{
42}
43
44void DiscoveryManagerTest::TearDownTestCase()
45{
46}
47
48namespace {
49    std::shared_ptr<SoftbusListener> softbusListener = std::make_shared<SoftbusListener>();
50    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
51    std::shared_ptr<DiscoveryManager> manager = std::make_shared<DiscoveryManager>(softbusListener, listener);
52
53bool checkSoftbusRes(int32_t ret)
54{
55    return ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR;
56}
57
58HWTEST_F(DiscoveryManagerTest, EnableDiscoveryListener_001, testing::ext::TestSize.Level0)
59{
60    std::string pkgName;
61    std::map<std::string, std::string> discoverParam;
62    std::map<std::string, std::string> filterOptions;
63    int32_t ret = manager->EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
64    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
65}
66
67HWTEST_F(DiscoveryManagerTest, EnableDiscoveryListener_002, testing::ext::TestSize.Level0)
68{
69    std::string pkgName = "pkgName";
70    std::map<std::string, std::string> discoverParam;
71    discoverParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
72    discoverParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
73    std::map<std::string, std::string> filterOptions;
74    int32_t ret = manager->EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
75    EXPECT_EQ(true, checkSoftbusRes(ret));
76}
77
78HWTEST_F(DiscoveryManagerTest, EnableDiscoveryListener_003, testing::ext::TestSize.Level0)
79{
80    std::string pkgName = "pkgName";
81    std::map<std::string, std::string> discoverParam;
82    std::map<std::string, std::string> filterOptions;
83    int32_t ret = manager->EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
84    EXPECT_EQ(true, checkSoftbusRes(ret));
85}
86
87HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_001, testing::ext::TestSize.Level0)
88{
89    std::string pkgName;
90    std::map<std::string, std::string> extraParam;
91    int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
92    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
93}
94
95HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_002, testing::ext::TestSize.Level0)
96{
97    std::string pkgName = "pkgName";
98    std::map<std::string, std::string> extraParam;
99    extraParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
100    extraParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
101    int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
102    EXPECT_EQ(true, checkSoftbusRes(ret));
103}
104
105HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_003, testing::ext::TestSize.Level0)
106{
107    std::string pkgName = "pkgName";
108    std::map<std::string, std::string> extraParam;
109    int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
110    EXPECT_EQ(true, checkSoftbusRes(ret));
111}
112
113HWTEST_F(DiscoveryManagerTest, StartDiscovering_001, testing::ext::TestSize.Level0)
114{
115    std::string pkgName;
116    std::map<std::string, std::string> discoverParam;
117    std::map<std::string, std::string> filterOptions;
118    int32_t ret = manager->StartDiscovering(pkgName, discoverParam, filterOptions);
119    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
120}
121
122HWTEST_F(DiscoveryManagerTest, StartDiscovering_002, testing::ext::TestSize.Level0)
123{
124    std::string pkgName = "pkgName";
125    std::map<std::string, std::string> discoverParam;
126    discoverParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
127    discoverParam.insert(std::pair<std::string, std::string>("DISC_MEDIUM", "ohos.test"));
128    discoverParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
129    discoverParam.insert(std::pair<std::string, std::string>("FILTER_OPTIONS", "ohos.test"));
130    std::map<std::string, std::string> filterOptions;
131    int32_t ret = manager->StartDiscovering(pkgName, discoverParam, filterOptions);
132    EXPECT_EQ(true, checkSoftbusRes(ret));
133}
134
135HWTEST_F(DiscoveryManagerTest, StartDiscovering_003, testing::ext::TestSize.Level0)
136{
137    std::string pkgName = "pkgName";
138    std::map<std::string, std::string> discoverParam;
139    std::map<std::string, std::string> filterOptions;
140    int32_t ret = manager->StartDiscovering(pkgName, discoverParam, filterOptions);
141    EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
142}
143
144HWTEST_F(DiscoveryManagerTest, StartDiscovering4MineLibary_001, testing::ext::TestSize.Level0)
145{
146    std::string pkgName = "pkgName";
147    DmSubscribeInfo dmSubInfo;
148    std::string searchJson = "searchJson";
149    int32_t ret = manager->StartDiscovering4MineLibary(pkgName, dmSubInfo, searchJson);
150    EXPECT_EQ(ret, ERR_DM_JSON_PARSE_STRING);
151}
152
153HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_001, testing::ext::TestSize.Level0)
154{
155    DmSubscribeInfo dmSubInfo;
156    std::string pkgName = "pkgNameTest01";
157    std::map<std::string, std::string> param;
158    param.insert(std::pair<std::string, std::string>("META_TYPE", std::to_string(MetaNodeType::PROXY_SHARE)));
159    int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
160    EXPECT_NE(ret, DM_OK);
161}
162
163HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_002, testing::ext::TestSize.Level0)
164{
165    DmSubscribeInfo dmSubInfo;
166    std::string pkgName = "pkgNameTest02";
167    std::map<std::string, std::string> param;
168    param.insert(std::pair<std::string, std::string>("META_TYPE", std::to_string(MetaNodeType::PROXY_WEAR)));
169    int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
170    EXPECT_NE(ret, DM_OK);
171}
172
173HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_003, testing::ext::TestSize.Level0)
174{
175    DmSubscribeInfo dmSubInfo;
176    std::string pkgName = "pkgNameTest03";
177    std::map<std::string, std::string> param;
178    param.insert(std::pair<std::string, std::string>("META_TYPE", std::to_string(MetaNodeType::PROXY_CASTPLUS)));
179    int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
180    EXPECT_NE(ret, DM_OK);
181}
182
183HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_004, testing::ext::TestSize.Level0)
184{
185    DmSubscribeInfo dmSubInfo;
186    std::string pkgName = "pkgNameTest04";
187    std::map<std::string, std::string> param;
188    int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
189    EXPECT_NE(ret, DM_OK);
190}
191
192HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_001, testing::ext::TestSize.Level0)
193{
194    DmSubscribeInfo dmSubInfo;
195    std::string pkgName = "pkgNameTest01";
196    std::map<std::string, std::string> param;
197    param.emplace("META_TYPE", "4");
198    int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
199    EXPECT_NE(ret, DM_OK);
200}
201
202HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_002, testing::ext::TestSize.Level0)
203{
204    DmSubscribeInfo dmSubInfo;
205    std::string pkgName = "pkgNameTest02";
206    std::map<std::string, std::string> param;
207    param.emplace("META_TYPE", "7");
208    int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
209    EXPECT_NE(ret, DM_OK);
210}
211
212HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_003, testing::ext::TestSize.Level0)
213{
214    DmSubscribeInfo dmSubInfo;
215    std::string pkgName = "pkgNameTest03";
216    std::map<std::string, std::string> param;
217    param.emplace("META_TYPE", "5");
218    int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
219    EXPECT_NE(ret, DM_OK);
220}
221
222HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_004, testing::ext::TestSize.Level0)
223{
224    DmSubscribeInfo dmSubInfo;
225    std::string pkgName = "pkgNameTest04";
226    std::map<std::string, std::string> param;
227    param.emplace("META_TYPE", "1234");
228    int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
229    EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
230}
231
232HWTEST_F(DiscoveryManagerTest, StopDiscovering_001, testing::ext::TestSize.Level0)
233{
234    std::string pkgName;
235    uint16_t subscribeId = 0;
236    int32_t ret = manager->StopDiscovering(pkgName, subscribeId);
237    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
238}
239
240HWTEST_F(DiscoveryManagerTest, StopDiscovering_002, testing::ext::TestSize.Level0)
241{
242    std::string pkgName = "pkgName";
243    uint16_t subscribeId = 0;
244    manager->pkgNameSet_.insert(pkgName);
245    DiscoveryContext context;
246    manager->discoveryContextMap_.emplace(pkgName, context);
247    int32_t ret = manager->StopDiscovering(pkgName, subscribeId);
248    EXPECT_EQ(true, checkSoftbusRes(ret));
249}
250
251HWTEST_F(DiscoveryManagerTest, OnDeviceFound_001, testing::ext::TestSize.Level0)
252{
253    std::string pkgName = "pkgName";
254    DmDeviceInfo info;
255    bool isOnline = false;
256    manager->OnDeviceFound(pkgName, info, isOnline);
257    EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
258}
259
260HWTEST_F(DiscoveryManagerTest, OnDeviceFound_002, testing::ext::TestSize.Level0)
261{
262    std::string pkgName = "pkgName";
263    DmDeviceInfo info;
264    bool isOnline = true;
265    manager->OnDeviceFound(pkgName, info, isOnline);
266    EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
267}
268
269HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_001, testing::ext::TestSize.Level0)
270{
271    std::string pkgName;
272    int32_t subscribeId = 1;
273    int32_t result = 0;
274    manager->OnDiscoveringResult(pkgName, subscribeId, result);
275    EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
276}
277
278HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_002, testing::ext::TestSize.Level0)
279{
280    std::string pkgName = "pkgName";
281    int32_t subscribeId = 1;
282    int32_t result = 0;
283    manager->listener_ = nullptr;
284    manager->OnDiscoveringResult(pkgName, subscribeId, result);
285    EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
286}
287
288HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_003, testing::ext::TestSize.Level0)
289{
290    std::string pkgName = "pkgName";
291    int32_t subscribeId = 1;
292    int32_t result = 0;
293    manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
294    manager->OnDiscoveringResult(pkgName, subscribeId, result);
295    EXPECT_NE(manager->discoveryContextMap_.empty(), true);
296}
297
298HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_004, testing::ext::TestSize.Level0)
299{
300    std::string pkgName = "pkgName";
301    int32_t subscribeId = 1;
302    int32_t result = 1;
303    manager->pkgNameSet_.insert(pkgName);
304    DiscoveryContext context;
305    manager->discoveryContextMap_.emplace(pkgName, context);
306    manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
307    manager->OnDiscoveringResult(pkgName, subscribeId, result);
308    EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
309}
310
311HWTEST_F(DiscoveryManagerTest, StartDiscoveryTimer_001, testing::ext::TestSize.Level0)
312{
313    manager->timer_ = nullptr;
314    std::string pkgName = "timeTest";
315    manager->StartDiscoveryTimer(pkgName);
316    EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
317}
318
319HWTEST_F(DiscoveryManagerTest, HandleDiscoveryQueue_001, testing::ext::TestSize.Level0)
320{
321    std::string pkgName = "pkgName";
322    uint16_t subscribeId = 0;
323    std::map<std::string, std::string> filterOps;
324    filterOps.insert(std::pair<std::string, std::string>("FILTER_OPTIONS", pkgName));
325    int32_t ret = manager->HandleDiscoveryQueue(pkgName, subscribeId, filterOps);
326    EXPECT_NE(ret, DM_OK);
327}
328
329HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_001, testing::ext::TestSize.Level0)
330{
331    std::string name = "nameTest01";
332    std::set<std::string> emptySet;
333    manager->pkgNameSet_ = emptySet;
334    manager->HandleDiscoveryTimeout(name);
335    EXPECT_EQ(manager->pkgNameSet_.empty(), true);
336}
337
338HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_002, testing::ext::TestSize.Level0)
339{
340    std::string name = "nameTest02";
341    manager->pkgNameSet_.insert(name);
342    manager->discoveryContextMap_.clear();
343    manager->HandleDiscoveryTimeout(name);
344    EXPECT_EQ(manager->pkgNameSet_.empty(), false);
345}
346
347HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_003, testing::ext::TestSize.Level0)
348{
349    manager->pkgNameSet_.clear();
350    std::string name = "nameTest03";
351    manager->pkgNameSet_.insert(name);
352    DiscoveryContext context;
353    manager->discoveryContextMap_.emplace(name, context);
354    manager->HandleDiscoveryTimeout(name);
355    EXPECT_NE(manager->pkgNameSet_.empty(), false);
356}
357
358HWTEST_F(DiscoveryManagerTest, GetDeviceAclParam_001, testing::ext::TestSize.Level0)
359{
360    std::string pkgName;
361    std::string deviceId;
362    bool isonline = true;
363    int32_t authForm = 0;
364    int32_t ret = manager->GetDeviceAclParam(pkgName, deviceId, isonline, authForm);
365    EXPECT_EQ(ret, DM_OK);
366}
367
368HWTEST_F(DiscoveryManagerTest, GetCommonDependencyObj_001, testing::ext::TestSize.Level0)
369{
370    auto ret = manager->GetCommonDependencyObj();
371    EXPECT_NE(ret, nullptr);
372}
373
374HWTEST_F(DiscoveryManagerTest, IsCommonDependencyReady_001, testing::ext::TestSize.Level0)
375{
376    manager->isSoLoaded_ = false;
377    bool ret = manager->IsCommonDependencyReady();
378    EXPECT_EQ(ret, true);
379}
380
381HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_001, testing::ext::TestSize.Level0)
382{
383    manager->isSoLoaded_ = false;
384    manager->dpConnector_ = nullptr;
385    manager->dpConnectorHandle_ = nullptr;
386    bool ret = manager->CloseCommonDependencyObj();
387    EXPECT_EQ(ret, true);
388}
389
390HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_002, testing::ext::TestSize.Level0)
391{
392    bool ret = manager->CloseCommonDependencyObj();
393    EXPECT_EQ(ret, true);
394}
395} // namespace
396} // namespace DistributedHardware
397} // namespace OHOS
398