1 /*
2 * Copyright (c) 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 <cstdio>
17
18 #include <gtest/gtest.h>
19
20 #include "net_manager_constants.h"
21 #define private public
22 #include "sharing_manager.h"
23 #undef private
24
25 namespace OHOS {
26 namespace NetsysNative {
27 namespace {
28 using namespace testing::ext;
29 using namespace nmd;
30 } // namespace
31
32 class SharingManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 static inline std::shared_ptr<SharingManager> sharingManager = nullptr;
39 };
40
SetUpTestCase()41 void SharingManagerTest::SetUpTestCase()
42 {
43 sharingManager = std::make_shared<SharingManager>();
44 }
45
TearDownTestCase()46 void SharingManagerTest::TearDownTestCase() {}
47
SetUp()48 void SharingManagerTest::SetUp() {}
49
TearDown()50 void SharingManagerTest::TearDown() {}
51
52 HWTEST_F(SharingManagerTest, IpEnableForwardingTest, TestSize.Level1)
53 {
54 auto result = sharingManager->IpEnableForwarding("aTestName");
55 ASSERT_EQ(result, 0);
56 }
57
58 HWTEST_F(SharingManagerTest, IpDisableForwarding, TestSize.Level1)
59 {
60 auto result = sharingManager->IpDisableForwarding("aTestName");
61 ASSERT_EQ(result, 0);
62 }
63
64 HWTEST_F(SharingManagerTest, EnableNat001, TestSize.Level1)
65 {
66 auto result = sharingManager->EnableNat("down", "up");
67 ASSERT_EQ(result, 0);
68 }
69
70 HWTEST_F(SharingManagerTest, EnableNat002, TestSize.Level1)
71 {
72 const std::string enableAction = "down";
73 int32_t ret = sharingManager->EnableNat(enableAction, enableAction);
74 ASSERT_EQ(ret, -1);
75
76 const std::string upstreamIface = "_test0";
77 ret = sharingManager->EnableNat(enableAction, upstreamIface);
78 ASSERT_EQ(ret, -1);
79
80 const std::string nullIface;
81 ret = sharingManager->EnableNat(enableAction, nullIface);
82 ASSERT_EQ(ret, -1);
83 }
84
85 HWTEST_F(SharingManagerTest, DisableNat001, TestSize.Level1)
86 {
87 sharingManager->DisableNat("down", "up");
88 ASSERT_STREQ("0", "0");
89 }
90
91 HWTEST_F(SharingManagerTest, DisableNat002, TestSize.Level1)
92 {
93 const std::string enableAction = "down";
94 int32_t ret = sharingManager->DisableNat(enableAction, enableAction);
95 ASSERT_EQ(ret, -1);
96
97 const std::string upstreamIface = "_test0";
98 ret = sharingManager->DisableNat(enableAction, upstreamIface);
99 ASSERT_EQ(ret, -1);
100
101 const std::string nullIface;
102 ret = sharingManager->DisableNat(enableAction, nullIface);
103 ASSERT_EQ(ret, -1);
104 }
105
106 HWTEST_F(SharingManagerTest, IpFwdAddInterfaceForward001, TestSize.Level1)
107 {
108 sharingManager->IpfwdAddInterfaceForward("down", "up");
109 ASSERT_STREQ("0", "0");
110 }
111
112 HWTEST_F(SharingManagerTest, IpFwdAddInterfaceForward002, TestSize.Level1)
113 {
114 const std::string enableAction = "down";
115 int32_t ret = sharingManager->IpfwdAddInterfaceForward(enableAction, enableAction);
116 ASSERT_EQ(ret, -1);
117 const std::string fromIface = "_err";
118 ret = sharingManager->IpfwdAddInterfaceForward(fromIface, enableAction);
119 EXPECT_EQ(ret, -1);
120 const std::string upstreamIface = "_test0";
121 ret = sharingManager->IpfwdAddInterfaceForward(enableAction, upstreamIface);
122 EXPECT_EQ(ret, -1);
123 }
124
125 HWTEST_F(SharingManagerTest, IpFwdRemoveInterfaceForward001, TestSize.Level1)
126 {
127 sharingManager->IpfwdRemoveInterfaceForward("down", "up");
128 ASSERT_STREQ("0", "0");
129 }
130
131 HWTEST_F(SharingManagerTest, IpFwdRemoveInterfaceForward002, TestSize.Level1)
132 {
133 const std::string enableAction = "down";
134 int32_t ret = sharingManager->IpfwdRemoveInterfaceForward(enableAction, enableAction);
135 ASSERT_EQ(ret, -1);
136 const std::string fromIface = "_err";
137 ret = sharingManager->IpfwdRemoveInterfaceForward(fromIface, enableAction);
138 EXPECT_EQ(ret, -1);
139 const std::string upstreamIface = "_test0";
140 ret = sharingManager->IpfwdRemoveInterfaceForward(enableAction, upstreamIface);
141 EXPECT_EQ(ret, -1);
142 }
143
144 HWTEST_F(SharingManagerTest, GetNetworkSharingTraffic001, TestSize.Level1)
145 {
146 std::string downIface = "down0";
147 std::string upIface = "up0";
148 NetworkSharingTraffic traffic;
149 int32_t ret = sharingManager->GetNetworkSharingTraffic(downIface, upIface, traffic);
150 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
151 }
152
153 HWTEST_F(SharingManagerTest, GetNetworkSharingTraffic002, TestSize.Level1)
154 {
155 std::string downIface = "eth0";
156 std::string upIface = "wlan0";
157 NetworkSharingTraffic traffic;
158 int32_t ret = sharingManager->GetNetworkSharingTraffic(downIface, upIface, traffic);
159 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
160 }
161
162 HWTEST_F(SharingManagerTest, SetIpFwdEnable001, TestSize.Level1)
163 {
164 int32_t ret = sharingManager->SetIpFwdEnable();
165 EXPECT_EQ(ret, 0);
166 ret = sharingManager->SetForwardRules(false, " tetherctrl_FORWARD -j DROP");
167 EXPECT_EQ(ret, 0);
168 }
169
170 HWTEST_F(SharingManagerTest, EnableNat003, TestSize.Level1)
171 {
172 std::string downstreamIface = "eth0";
173 auto result = sharingManager->EnableNat(downstreamIface, downstreamIface);
174 EXPECT_EQ(result, -1);
175 }
176
177 HWTEST_F(SharingManagerTest, IpfwdAddInterfaceForward003, TestSize.Level1)
178 {
179 std::string fromIface = "down";
180 std::string toIface = "up";
181 sharingManager->interfaceForwards_ = {"123"};
182 auto result = sharingManager->IpfwdAddInterfaceForward(fromIface, toIface);
183 EXPECT_EQ(result, 0);
184 }
185
186 HWTEST_F(SharingManagerTest, IpfwdRemoveInterfaceForward003, TestSize.Level1)
187 {
188 std::string fromIface = "down";
189 std::string toIface = "up";
190 sharingManager->interfaceForwards_ = {"123"};
191 auto result = sharingManager->IpfwdRemoveInterfaceForward(fromIface, toIface);
192 EXPECT_EQ(result, 0);
193 }
194
195 HWTEST_F(SharingManagerTest, QueryCellularSharingTraffic001, TestSize.Level1)
196 {
197 NetworkSharingTraffic traffic;
198 std::string ifaceName = "";
199 std::string result = "Chain tetherctrl_counters (2 references) \n"
200 "pkts bytes target prot opt in out source destination \n"
201 " 0 0 RETURN all -- wlan0 wlan1 0.0.0.0/0 0.0.0.0/0 \n"
202 " 0 0 RETURN all -- wlan1 wlan0 0.0.0.0/0 0.0.0.0/0 \n";
203 auto res = sharingManager->QueryCellularSharingTraffic(traffic, result, ifaceName);
204 EXPECT_EQ(res, 0);
205 }
206
207 HWTEST_F(SharingManagerTest, QueryCellularSharingTraffic002, TestSize.Level1)
208 {
209 NetworkSharingTraffic traffic;
210 std::string ifaceName = "";
211 std::string result = "Chain tetherctrl_counters (2 references) \n"
212 "pkts bytes target prot opt in out source destination \n"
213 " 0 0 RETURN all -- rmnet0 wlan1 0.0.0.0/0 0.0.0.0/0 \n"
214 " 0 0 RETURN all -- wlan1 rmnet0 0.0.0.0/0 0.0.0.0/0 \n";
215 auto res = sharingManager->QueryCellularSharingTraffic(traffic, result, ifaceName);
216 EXPECT_EQ(res, 0);
217 }
218
219 HWTEST_F(SharingManagerTest, QueryCellularSharingTraffic003, TestSize.Level1)
220 {
221 NetworkSharingTraffic traffic;
222 std::string ifaceName = "";
223 std::string result = "Chain tetherctrl_counters (2 references) \n"
224 "pkts bytes target prot opt in out source destination \n"
225 " 0 0 RETURN all -- wifi0 wifi1 0.0.0.0/0 0.0.0.0/0 \n"
226 " 0 0 RETURN all -- wifi1 wifi0 0.0.0.0/0 0.0.0.0/0 \n";
227 auto res = sharingManager->QueryCellularSharingTraffic(traffic, result, ifaceName);
228 EXPECT_EQ(res, -1);
229 }
230
231 HWTEST_F(SharingManagerTest, QueryCellularSharingTraffic004, TestSize.Level1)
232 {
233 NetworkSharingTraffic traffic;
234 std::string ifaceName = "";
235 std::string result = "Chain tetherctrl_counters (2 references) \n"
236 "pkts bytes target prot opt in out source destination \n"
237 " 0 0 RETURN all -- wifi0 0.0.0.0/0 0.0.0.0/0 \n"
238 " 0 0 RETURN all -- wifi1 0.0.0.0/0 0.0.0.0/0 \n";
239 auto res = sharingManager->QueryCellularSharingTraffic(traffic, result, ifaceName);
240 EXPECT_EQ(res, -1);
241 }
242 } // namespace NetsysNative
243 } // namespace OHOS
244