1 /*
2 * Copyright (c) 2023 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 <gtest/gtest.h>
17 #include "disabled_network_interface_plugin.h"
18 #include "edm_ipc_interface_code.h"
19 #include "get_all_network_interfaces_plugin.h"
20 #include "get_ip_address_plugin.h"
21 #include "get_mac_plugin.h"
22 #include "iplugin_manager.h"
23 #include "plugin_singleton.h"
24 #include "utils.h"
25
26 using namespace testing::ext;
27 using namespace testing;
28
29 namespace OHOS {
30 namespace EDM {
31 namespace TEST {
32 const std::string VALID_NETWORK_INTERFACE = "lo";
33 const std::string INVALID_NETWORK_INTERFACE = "fail";
34
35 class NetworkManagerPluginTest : public testing::Test {
36 protected:
37 static void SetUpTestSuite(void);
38
39 static void TearDownTestSuite(void);
40 };
41
SetUpTestSuite(void)42 void NetworkManagerPluginTest::SetUpTestSuite(void)
43 {
44 Utils::SetEdmInitialEnv();
45 }
46
TearDownTestSuite(void)47 void NetworkManagerPluginTest::TearDownTestSuite(void)
48 {
49 Utils::ResetTokenTypeAndUid();
50 ASSERT_TRUE(Utils::IsOriginalUTEnv());
51 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
52 }
53
54 /**
55 * @tc.name: TestGetAllNetworkInterfaces
56 * @tc.desc: Test GetAllNetworkInterfacesPlugin.
57 * @tc.type: FUNC
58 */
59 HWTEST_F(NetworkManagerPluginTest, TestGetAllNetworkInterfaces, TestSize.Level1)
60 {
61 std::shared_ptr<IPlugin> plugin = GetAllNetworkInterfacesPlugin::GetPlugin();
62 std::string policyData{"TestGetAllNetworkInterfaces"};
63 MessageParcel data;
64 MessageParcel reply;
65 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
66 ASSERT_TRUE(ret == ERR_OK);
67 }
68
69 /**
70 * @tc.name: TestGetIpAddress
71 * @tc.desc: Test GetIpAddressPlugin.
72 * @tc.type: FUNC
73 */
74 HWTEST_F(NetworkManagerPluginTest, TestGetIpAddress, TestSize.Level1)
75 {
76 std::shared_ptr<IPlugin> plugin = GetIpAddressPlugin::GetPlugin();
77 std::string policyData{"TestGetIpAddress"};
78 MessageParcel data;
79 MessageParcel reply;
80 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
81 ASSERT_TRUE(ret == ERR_OK);
82 }
83
84 /**
85 * @tc.name: TestGetMac
86 * @tc.desc: Test GetMacPlugin.
87 * @tc.type: FUNC
88 */
89 HWTEST_F(NetworkManagerPluginTest, TestGetMac, TestSize.Level1)
90 {
91 std::shared_ptr<IPlugin> plugin = GetMacPlugin::GetPlugin();
92 std::string policyData{"TestGetMac"};
93 MessageParcel data;
94 MessageParcel reply;
95 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
96 ASSERT_TRUE(ret == ERR_OK);
97 }
98
99 /**
100 * @tc.name: TestIsNetworkInterfaceDisabled
101 * @tc.desc: Test IsNetworkInterfaceDisabled fail.
102 * @tc.type: FUNC
103 */
104 HWTEST_F(NetworkManagerPluginTest, TestIsNetworkInterfaceDisabledFail, TestSize.Level1)
105 {
106 std::shared_ptr<IPlugin> plugin = DisabledNetworkInterfacePlugin::GetPlugin();
107 std::string policyData;
108 MessageParcel data;
109 MessageParcel reply;
110 // NetworkInterface is not exist.
111 data.WriteString(INVALID_NETWORK_INTERFACE);
112 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
113 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
114 }
115
116 /**
117 * @tc.name: TestIsNetworkInterfaceDisabled
118 * @tc.desc: Test IsNetworkInterfaceDisabled success.
119 * @tc.type: FUNC
120 */
121 HWTEST_F(NetworkManagerPluginTest, TestIsNetworkInterfaceDisabledSuc, TestSize.Level1)
122 {
123 std::shared_ptr<IPlugin> plugin = DisabledNetworkInterfacePlugin::GetPlugin();
124 std::string policyData;
125 MessageParcel data;
126 MessageParcel reply;
127 // NetworkInterface is exist.
128 data.WriteString(VALID_NETWORK_INTERFACE);
129 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
130 ASSERT_TRUE(ret == ERR_OK);
131 }
132
133 /**
134 * @tc.name: TestNetworkInterfaceNotExist
135 * @tc.desc: Test SetNetworkInterfaceDisabled when NetworkInterface is not exist.
136 * @tc.type: FUNC
137 */
138 HWTEST_F(NetworkManagerPluginTest, TestNetworkInterfaceNotExist, TestSize.Level1)
139 {
140 std::shared_ptr<IPlugin> plugin = DisabledNetworkInterfacePlugin::GetPlugin();
141 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_NETWORK_INTERFACE);
142 // data is empty.
143 MessageParcel data;
144 MessageParcel reply;
145 HandlePolicyData handlePolicyData{"", false};
146 ErrCode ret = plugin->OnHandlePolicy(code, data, reply, handlePolicyData, DEFAULT_USER_ID);
147 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
148 // NetworkInterface is invalid.
149 std::vector<std::string> key { INVALID_NETWORK_INTERFACE };
150 std::vector<std::string> value { "true" };
151 data.WriteStringVector(key);
152 data.WriteStringVector(value);
153 ret = plugin->OnHandlePolicy(code, data, reply, handlePolicyData, DEFAULT_USER_ID);
154 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
155 }
156
157 /**
158 * @tc.name: TestNetworkInterfaceDisabled
159 * @tc.desc: Test SetNetworkInterfaceDisabled when set network interface disabled.
160 * @tc.type: FUNC
161 */
162 HWTEST_F(NetworkManagerPluginTest, TestNetworkInterfaceDisabled, TestSize.Level1)
163 {
164 std::shared_ptr<IPlugin> plugin = DisabledNetworkInterfacePlugin::GetPlugin();
165 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_NETWORK_INTERFACE);
166 MessageParcel data;
167 MessageParcel reply;
168 std::string policyStr;
169 HandlePolicyData handlePolicyData;
170 // set network interface disabled.
171 std::vector<std::string> key { VALID_NETWORK_INTERFACE };
172 std::vector<std::string> value { "true" };
173 data.WriteStringVector(key);
174 data.WriteStringVector(value);
175 ErrCode ret = plugin->OnHandlePolicy(code, data, reply, handlePolicyData, DEFAULT_USER_ID);
176 ASSERT_TRUE(ret == ERR_OK);
177 // get policy.
178 data.WriteString(VALID_NETWORK_INTERFACE);
179 ret = plugin->OnGetPolicy(policyStr, data, reply, DEFAULT_USER_ID);
180 ASSERT_TRUE(ret == ERR_OK);
181 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
182 ASSERT_TRUE(reply.ReadBool());
183 // set network interface enabled.
184 value = { "false" };
185 data.WriteStringVector(key);
186 data.WriteStringVector(value);
187 ret = plugin->OnHandlePolicy(code, data, reply, handlePolicyData, DEFAULT_USER_ID);
188 ASSERT_TRUE(ret == ERR_OK);
189 // get policy.
190 data.WriteString(VALID_NETWORK_INTERFACE);
191 ret = plugin->OnGetPolicy(policyStr, data, reply, DEFAULT_USER_ID);
192 ASSERT_TRUE(ret == ERR_OK);
193 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
194 ASSERT_FALSE(reply.ReadBool());
195 }
196 } // namespace TEST
197 } // namespace EDM
198 } // namespace OHOS