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_dm_comm_tool.h"
17 #include <memory>
18 #include "dm_error_type.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace DistributedHardware {
SetUp()25 void DMCommToolTest::SetUp()
26 {
27 dmCommTool = DMCommTool::GetInstance();
28 dmCommTool->Init();
29 }
TearDown()30 void DMCommToolTest::TearDown()
31 {
32 }
SetUpTestCase()33 void DMCommToolTest::SetUpTestCase()
34 {
35 DmDMTransport::dMTransport_ = dmTransportMock_;
36 DmSoftbusCache::dmSoftbusCache = softbusCacheMock_;
37 }
TearDownTestCase()38 void DMCommToolTest::TearDownTestCase()
39 {
40 DmDMTransport::dMTransport_ = nullptr;
41 dmTransportMock_ = nullptr;
42 DmSoftbusCache::dmSoftbusCache = nullptr;
43 softbusCacheMock_ = nullptr;
44 }
45
46 /**
47 * @tc.name: GetEventHandler_NotNull
48 * @tc.type: FUNC
49 */
50 HWTEST_F(DMCommToolTest, GetEventHandler_NotNull, testing::ext::TestSize.Level0)
51 {
52 auto handler = dmCommTool->GetEventHandler();
53 EXPECT_NE(handler, nullptr);
54 }
55
56 /**
57 * @tc.name: GetDMTransportPtr_NotNull
58 * @tc.type: FUNC
59 */
60 HWTEST_F(DMCommToolTest, GetDMTransportPtr_NotNull, testing::ext::TestSize.Level0)
61 {
62 auto transportPtr = dmCommTool->GetDMTransportPtr();
63 EXPECT_NE(transportPtr, nullptr);
64 }
65
66 HWTEST_F(DMCommToolTest, SendUserIds_001, testing::ext::TestSize.Level0)
67 {
68 std::string rmtNetworkId = "";
69 std::vector<uint32_t> foregroundUserIds;
70 std::vector<uint32_t> backgroundUserIds;
71 int32_t ret = dmCommTool->SendUserIds(rmtNetworkId, foregroundUserIds, backgroundUserIds);
72 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
73
74 rmtNetworkId = "rmtNetworkId";
75 foregroundUserIds.push_back(1);
76 EXPECT_CALL(*dmTransportMock_, StartSocket(_, _)).WillOnce(Return(ERR_DM_FAILED));
77 ret = dmCommTool->SendUserIds(rmtNetworkId, foregroundUserIds, backgroundUserIds);
78 EXPECT_EQ(ret, ERR_DM_FAILED);
79
80 backgroundUserIds.push_back(10);
81 EXPECT_CALL(*dmTransportMock_, StartSocket(_, _)).WillOnce(DoAll(SetArgReferee<1>(1), Return(DM_OK)));
82 EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(ERR_DM_FAILED));
83 ret = dmCommTool->SendUserIds(rmtNetworkId, foregroundUserIds, backgroundUserIds);
84 EXPECT_EQ(ret, ERR_DM_FAILED);
85
86 EXPECT_CALL(*dmTransportMock_, StartSocket(_, _)).WillOnce(DoAll(SetArgReferee<1>(1), Return(DM_OK)));
87 EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
88 ret = dmCommTool->SendUserIds(rmtNetworkId, foregroundUserIds, backgroundUserIds);
89 EXPECT_EQ(ret, DM_OK);
90
91 int32_t socketId = 1;
92 EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).Times(::testing::AtLeast(2)).WillOnce(Return(ERR_DM_FAILED));
93 dmCommTool->RspLocalFrontOrBackUserIds(rmtNetworkId, foregroundUserIds, backgroundUserIds, socketId);
94
95 std::string remoteNetworkId = "network******12";
96 std::string strMsg = R"({
97 "MsgType": "0",
98 "userId": "12345",
99 "syncUserIdFlag": 1,
100 "userIds": [
101 {"type": 1, "userId": 111},
102 {"type": 0, "userId": 222}
103 ]
104 })";
105 std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, strMsg);
106 socketId = 0;
107 std::shared_ptr<InnerCommMsg> InnerCommMsg_ = std::make_shared<InnerCommMsg>(remoteNetworkId, commMsg_, socketId);
108 std::string rmtUdid = "";
109 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
110 .WillOnce(DoAll(SetArgReferee<1>(rmtUdid), Return(ERR_DM_FAILED)));
111 dmCommTool->ProcessReceiveUserIdsEvent(InnerCommMsg_);
112 rmtUdid = "b*********12";
113 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
114 .WillOnce(DoAll(SetArgReferee<1>(rmtUdid), Return(ERR_DM_FAILED)));
115 dmCommTool->ProcessReceiveUserIdsEvent(InnerCommMsg_);
116 }
117
118 HWTEST_F(DMCommToolTest, ProcessResponseUserIdsEvent_001, testing::ext::TestSize.Level0)
119 {
120 std::string remoteNetworkId = "network******12";
121 std::string strMsg = R"({
122 "MsgType": "0",
123 "userId": "12345",
124 "syncUserIdFlag": 1,
125 "foregroundUserIds": [10, 11, 12],
126 "backgroundUserIds": [101, 112, 123],
127 "userIds": [
128 {"type": 1, "userId": 111},
129 {"type": 0, "userId": 222}
130 ]
131 })";
132 std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, strMsg);
133 int32_t socketId = 0;
134 std::shared_ptr<InnerCommMsg> InnerCommMsg_ = std::make_shared<InnerCommMsg>(remoteNetworkId, commMsg_, socketId);
135 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
136 .WillOnce(DoAll(SetArgReferee<1>(""), Return(ERR_DM_FAILED)));
137 dmCommTool->ProcessResponseUserIdsEvent(InnerCommMsg_);
138
139 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
140 .WillOnce(DoAll(SetArgReferee<1>("rmtUdid"), Return(ERR_DM_FAILED)));
141 dmCommTool->ProcessResponseUserIdsEvent(InnerCommMsg_);
142
143 std::string rmtNetworkId = "";
144 std::vector<uint32_t> foregroundUserIds;
145 std::vector<uint32_t> backgroundUserIds;
146 int32_t ret = dmCommTool->SendUserIds(rmtNetworkId, foregroundUserIds, backgroundUserIds);
147 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
148 }
149 } // DistributedHardware
150 } // OHOS