1 #include "config_parser.hpp"
2 #include "dhcp_configuration.hpp"
3 #include "mock_ethernet_interface.hpp"
4 #include "test_network_manager.hpp"
5
6 #include <net/if_arp.h>
7
8 #include <sdbusplus/bus.hpp>
9 #include <stdplus/gtest/tmp.hpp>
10
11 #include <filesystem>
12 #include <fstream>
13 #include <string_view>
14
15 #include <gtest/gtest.h>
16
17 namespace phosphor
18 {
19 namespace network
20 {
21 namespace dhcp
22 {
23
24 using std::literals::string_view_literals::operator""sv;
25 using testing::Return;
26
27 class TestDHCPConfiguration : public stdplus::gtest::TestWithTmp
28 {
29 public:
30 stdplus::Pinned<sdbusplus::bus_t> bus;
31 std::filesystem::path confDir;
32 TestManager manager;
33 MockEthernetInterface interface;
34 static inline int testCounter = 0;
35 int currentTestId;
36
TestDHCPConfiguration()37 TestDHCPConfiguration() :
38 bus(sdbusplus::bus::new_default()), confDir(CaseTmpDir()),
39 manager(bus, "/xyz/openbmc_test/network", confDir),
40 interface(makeInterface(bus, manager)), currentTestId(testCounter++)
41 {}
42
makeInterface(stdplus::PinnedRef<sdbusplus::bus_t> bus,TestManager & manager)43 static MockEthernetInterface makeInterface(
44 stdplus::PinnedRef<sdbusplus::bus_t> bus, TestManager& manager)
45 {
46 AllIntfInfo info{InterfaceInfo{
47 .type = ARPHRD_ETHER, .idx = 1, .flags = 0, .name = "test0"}};
48 return {bus, manager, info, "/xyz/openbmc_test/network"sv,
49 config::Parser()};
50 }
51
writeConfigFile(const std::string & content)52 void writeConfigFile(const std::string& content)
53 {
54 auto confPath = confDir / "00-bmc-test0.network";
55 std::ofstream file(confPath);
56 file << content;
57 file.close();
58 }
59
createDHCPv4Config()60 std::unique_ptr<Configuration> createDHCPv4Config()
61 {
62 EthernetInterface& ethIntf = interface;
63 return std::make_unique<Configuration>(
64 bus,
65 "/xyz/openbmc_test/network/test0/dhcp4_" +
66 std::to_string(currentTestId),
67 ethIntf, DHCPType::v4);
68 }
69
createDHCPv6Config()70 std::unique_ptr<Configuration> createDHCPv6Config()
71 {
72 EthernetInterface& ethIntf = interface;
73 return std::make_unique<Configuration>(
74 bus,
75 "/xyz/openbmc_test/network/test0/dhcp6_" +
76 std::to_string(currentTestId),
77 ethIntf, DHCPType::v6);
78 }
79 };
80
TEST_F(TestDHCPConfiguration,ConstructorDHCPv4DefaultValues)81 TEST_F(TestDHCPConfiguration, ConstructorDHCPv4DefaultValues)
82 {
83 auto dhcp = createDHCPv4Config();
84
85 EXPECT_TRUE(dhcp->dnsEnabled());
86 EXPECT_TRUE(dhcp->ntpEnabled());
87 EXPECT_TRUE(dhcp->hostNameEnabled());
88 EXPECT_TRUE(dhcp->sendHostNameEnabled());
89 EXPECT_TRUE(dhcp->domainEnabled());
90 }
91
TEST_F(TestDHCPConfiguration,ConstructorDHCPv4LoadFromConfig)92 TEST_F(TestDHCPConfiguration, ConstructorDHCPv4LoadFromConfig)
93 {
94 writeConfigFile(R"([Network]
95 DHCP=ipv4
96 [DHCPv4]
97 UseDNS=true
98 UseNTP=true
99 UseHostname=true
100 SendHostname=true
101 UseDomains=true
102 )");
103
104 auto dhcp = createDHCPv4Config();
105
106 EXPECT_TRUE(dhcp->dnsEnabled());
107 EXPECT_TRUE(dhcp->ntpEnabled());
108 EXPECT_TRUE(dhcp->hostNameEnabled());
109 EXPECT_TRUE(dhcp->sendHostNameEnabled());
110 EXPECT_TRUE(dhcp->domainEnabled());
111 }
112
TEST_F(TestDHCPConfiguration,ConstructorDHCPv6DefaultValues)113 TEST_F(TestDHCPConfiguration, ConstructorDHCPv6DefaultValues)
114 {
115 auto dhcp = createDHCPv6Config();
116
117 EXPECT_TRUE(dhcp->dnsEnabled());
118 EXPECT_TRUE(dhcp->ntpEnabled());
119 EXPECT_TRUE(dhcp->hostNameEnabled());
120 EXPECT_TRUE(dhcp->sendHostNameEnabled());
121 EXPECT_TRUE(dhcp->domainEnabled());
122 }
123
TEST_F(TestDHCPConfiguration,ConstructorDHCPv6LoadFromConfig)124 TEST_F(TestDHCPConfiguration, ConstructorDHCPv6LoadFromConfig)
125 {
126 writeConfigFile(R"([Network]
127 DHCP=ipv6
128 [DHCPv6]
129 UseDNS=true
130 UseNTP=false
131 UseHostname=true
132 SendHostname=false
133 UseDomains=true
134 )");
135
136 auto dhcp = createDHCPv6Config();
137
138 EXPECT_TRUE(dhcp->dnsEnabled());
139 EXPECT_FALSE(dhcp->ntpEnabled());
140 EXPECT_TRUE(dhcp->hostNameEnabled());
141 EXPECT_FALSE(dhcp->sendHostNameEnabled());
142 EXPECT_TRUE(dhcp->domainEnabled());
143 }
144
TEST_F(TestDHCPConfiguration,SetDNSEnabledTrue)145 TEST_F(TestDHCPConfiguration, SetDNSEnabledTrue)
146 {
147 auto dhcp = createDHCPv4Config();
148 EXPECT_TRUE(dhcp->dnsEnabled());
149
150 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
151 EXPECT_TRUE(dhcp->dnsEnabled(true));
152 EXPECT_TRUE(dhcp->dnsEnabled());
153 }
154
TEST_F(TestDHCPConfiguration,SetDNSEnabledFalse)155 TEST_F(TestDHCPConfiguration, SetDNSEnabledFalse)
156 {
157 writeConfigFile(R"([DHCPv4]
158 UseDNS=true
159 )");
160 auto dhcp = createDHCPv4Config();
161 EXPECT_TRUE(dhcp->dnsEnabled());
162
163 EXPECT_CALL(manager.mockReload, schedule());
164 EXPECT_FALSE(dhcp->dnsEnabled(false));
165 EXPECT_FALSE(dhcp->dnsEnabled());
166 }
167
TEST_F(TestDHCPConfiguration,SetDNSEnabledNoOpSameValue)168 TEST_F(TestDHCPConfiguration, SetDNSEnabledNoOpSameValue)
169 {
170 auto dhcp = createDHCPv4Config();
171 EXPECT_TRUE(dhcp->dnsEnabled());
172
173 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
174 EXPECT_TRUE(dhcp->dnsEnabled(true));
175 }
176
TEST_F(TestDHCPConfiguration,SetNTPEnabledTrue)177 TEST_F(TestDHCPConfiguration, SetNTPEnabledTrue)
178 {
179 auto dhcp = createDHCPv4Config();
180 EXPECT_TRUE(dhcp->ntpEnabled());
181
182 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
183 EXPECT_TRUE(dhcp->ntpEnabled(true));
184 EXPECT_TRUE(dhcp->ntpEnabled());
185 }
186
TEST_F(TestDHCPConfiguration,SetNTPEnabledFalse)187 TEST_F(TestDHCPConfiguration, SetNTPEnabledFalse)
188 {
189 writeConfigFile(R"([DHCPv4]
190 UseNTP=true
191 )");
192 auto dhcp = createDHCPv4Config();
193 EXPECT_TRUE(dhcp->ntpEnabled());
194
195 EXPECT_CALL(manager.mockReload, schedule());
196 EXPECT_FALSE(dhcp->ntpEnabled(false));
197 EXPECT_FALSE(dhcp->ntpEnabled());
198 }
199
TEST_F(TestDHCPConfiguration,SetNTPEnabledNoOpSameValue)200 TEST_F(TestDHCPConfiguration, SetNTPEnabledNoOpSameValue)
201 {
202 auto dhcp = createDHCPv4Config();
203 EXPECT_TRUE(dhcp->ntpEnabled());
204
205 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
206 EXPECT_TRUE(dhcp->ntpEnabled(true));
207 }
208
TEST_F(TestDHCPConfiguration,SetHostNameEnabledTrue)209 TEST_F(TestDHCPConfiguration, SetHostNameEnabledTrue)
210 {
211 auto dhcp = createDHCPv4Config();
212 EXPECT_TRUE(dhcp->hostNameEnabled());
213
214 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
215 EXPECT_TRUE(dhcp->hostNameEnabled(true));
216 EXPECT_TRUE(dhcp->hostNameEnabled());
217 }
218
TEST_F(TestDHCPConfiguration,SetHostNameEnabledFalse)219 TEST_F(TestDHCPConfiguration, SetHostNameEnabledFalse)
220 {
221 writeConfigFile(R"([DHCPv4]
222 UseHostname=true
223 )");
224 auto dhcp = createDHCPv4Config();
225 EXPECT_TRUE(dhcp->hostNameEnabled());
226
227 EXPECT_CALL(manager.mockReload, schedule());
228 EXPECT_FALSE(dhcp->hostNameEnabled(false));
229 EXPECT_FALSE(dhcp->hostNameEnabled());
230 }
231
TEST_F(TestDHCPConfiguration,SetHostNameEnabledNoOpSameValue)232 TEST_F(TestDHCPConfiguration, SetHostNameEnabledNoOpSameValue)
233 {
234 auto dhcp = createDHCPv4Config();
235 EXPECT_TRUE(dhcp->hostNameEnabled());
236
237 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
238 EXPECT_TRUE(dhcp->hostNameEnabled(true));
239 }
240
TEST_F(TestDHCPConfiguration,SetSendHostNameEnabledTrue)241 TEST_F(TestDHCPConfiguration, SetSendHostNameEnabledTrue)
242 {
243 auto dhcp = createDHCPv4Config();
244 EXPECT_TRUE(dhcp->sendHostNameEnabled());
245
246 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
247 EXPECT_TRUE(dhcp->sendHostNameEnabled(true));
248 EXPECT_TRUE(dhcp->sendHostNameEnabled());
249 }
250
TEST_F(TestDHCPConfiguration,SetSendHostNameEnabledFalse)251 TEST_F(TestDHCPConfiguration, SetSendHostNameEnabledFalse)
252 {
253 writeConfigFile(R"([DHCPv4]
254 SendHostname=true
255 )");
256 auto dhcp = createDHCPv4Config();
257 EXPECT_TRUE(dhcp->sendHostNameEnabled());
258
259 EXPECT_CALL(manager.mockReload, schedule());
260 EXPECT_FALSE(dhcp->sendHostNameEnabled(false));
261 EXPECT_FALSE(dhcp->sendHostNameEnabled());
262 }
263
TEST_F(TestDHCPConfiguration,SetSendHostNameEnabledNoOpSameValue)264 TEST_F(TestDHCPConfiguration, SetSendHostNameEnabledNoOpSameValue)
265 {
266 auto dhcp = createDHCPv4Config();
267 EXPECT_TRUE(dhcp->sendHostNameEnabled());
268
269 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
270 EXPECT_TRUE(dhcp->sendHostNameEnabled(true));
271 }
272
TEST_F(TestDHCPConfiguration,SetDomainEnabledTrue)273 TEST_F(TestDHCPConfiguration, SetDomainEnabledTrue)
274 {
275 auto dhcp = createDHCPv4Config();
276 EXPECT_TRUE(dhcp->domainEnabled());
277
278 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
279 EXPECT_TRUE(dhcp->domainEnabled(true));
280 EXPECT_TRUE(dhcp->domainEnabled());
281 }
282
TEST_F(TestDHCPConfiguration,SetDomainEnabledFalse)283 TEST_F(TestDHCPConfiguration, SetDomainEnabledFalse)
284 {
285 writeConfigFile(R"([DHCPv4]
286 UseDomains=true
287 )");
288 auto dhcp = createDHCPv4Config();
289 EXPECT_TRUE(dhcp->domainEnabled());
290
291 EXPECT_CALL(manager.mockReload, schedule());
292 EXPECT_FALSE(dhcp->domainEnabled(false));
293 EXPECT_FALSE(dhcp->domainEnabled());
294 }
295
TEST_F(TestDHCPConfiguration,SetDomainEnabledNoOpSameValue)296 TEST_F(TestDHCPConfiguration, SetDomainEnabledNoOpSameValue)
297 {
298 auto dhcp = createDHCPv4Config();
299 EXPECT_TRUE(dhcp->domainEnabled());
300
301 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
302 EXPECT_TRUE(dhcp->domainEnabled(true));
303 }
304
TEST_F(TestDHCPConfiguration,SetMultiplePropertiesSequentially)305 TEST_F(TestDHCPConfiguration, SetMultiplePropertiesSequentially)
306 {
307 auto dhcp = createDHCPv4Config();
308
309 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
310
311 dhcp->dnsEnabled(true);
312 dhcp->ntpEnabled(true);
313 dhcp->hostNameEnabled(true);
314 dhcp->sendHostNameEnabled(true);
315 dhcp->domainEnabled(true);
316
317 EXPECT_TRUE(dhcp->dnsEnabled());
318 EXPECT_TRUE(dhcp->ntpEnabled());
319 EXPECT_TRUE(dhcp->hostNameEnabled());
320 EXPECT_TRUE(dhcp->sendHostNameEnabled());
321 EXPECT_TRUE(dhcp->domainEnabled());
322 }
323
TEST_F(TestDHCPConfiguration,TogglePropertiesMultipleTimes)324 TEST_F(TestDHCPConfiguration, TogglePropertiesMultipleTimes)
325 {
326 auto dhcp = createDHCPv4Config();
327
328 EXPECT_CALL(manager.mockReload, schedule()).Times(3);
329
330 dhcp->dnsEnabled(false);
331 EXPECT_FALSE(dhcp->dnsEnabled());
332
333 dhcp->dnsEnabled(true);
334 EXPECT_TRUE(dhcp->dnsEnabled());
335
336 dhcp->dnsEnabled(false);
337 EXPECT_FALSE(dhcp->dnsEnabled());
338 }
339
TEST_F(TestDHCPConfiguration,DHCPv6AllPropertiesEnabled)340 TEST_F(TestDHCPConfiguration, DHCPv6AllPropertiesEnabled)
341 {
342 auto dhcp = createDHCPv6Config();
343
344 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
345
346 dhcp->dnsEnabled(true);
347 dhcp->ntpEnabled(true);
348 dhcp->hostNameEnabled(true);
349 dhcp->sendHostNameEnabled(true);
350 dhcp->domainEnabled(true);
351
352 EXPECT_TRUE(dhcp->dnsEnabled());
353 EXPECT_TRUE(dhcp->ntpEnabled());
354 EXPECT_TRUE(dhcp->hostNameEnabled());
355 EXPECT_TRUE(dhcp->sendHostNameEnabled());
356 EXPECT_TRUE(dhcp->domainEnabled());
357 }
358
TEST_F(TestDHCPConfiguration,PartialConfigurationEnabled)359 TEST_F(TestDHCPConfiguration, PartialConfigurationEnabled)
360 {
361 auto dhcp = createDHCPv4Config();
362
363 EXPECT_CALL(manager.mockReload, schedule()).Times(2);
364
365 dhcp->dnsEnabled(true);
366 dhcp->ntpEnabled(true);
367 dhcp->hostNameEnabled(false);
368 dhcp->sendHostNameEnabled(false);
369 dhcp->domainEnabled(true);
370
371 EXPECT_TRUE(dhcp->dnsEnabled());
372 EXPECT_TRUE(dhcp->ntpEnabled());
373 EXPECT_FALSE(dhcp->hostNameEnabled());
374 EXPECT_FALSE(dhcp->sendHostNameEnabled());
375 EXPECT_TRUE(dhcp->domainEnabled());
376 }
377
TEST_F(TestDHCPConfiguration,ConfigWrittenAfterUpdate)378 TEST_F(TestDHCPConfiguration, ConfigWrittenAfterUpdate)
379 {
380 auto dhcp = createDHCPv4Config();
381
382 EXPECT_CALL(manager.mockReload, schedule());
383 dhcp->dnsEnabled(false);
384
385 auto confPath = confDir / "00-bmc-test0.network";
386 EXPECT_TRUE(std::filesystem::exists(confPath));
387 }
388
TEST_F(TestDHCPConfiguration,RapidPropertyChanges)389 TEST_F(TestDHCPConfiguration, RapidPropertyChanges)
390 {
391 auto dhcp = createDHCPv4Config();
392
393 EXPECT_CALL(manager.mockReload, schedule()).Times(10);
394
395 for (int i = 0; i < 5; ++i)
396 {
397 dhcp->dnsEnabled(false);
398 dhcp->dnsEnabled(true);
399 }
400 }
401
TEST_F(TestDHCPConfiguration,AllPropertiesDisabled)402 TEST_F(TestDHCPConfiguration, AllPropertiesDisabled)
403 {
404 writeConfigFile(R"([DHCPv4]
405 UseDNS=true
406 UseNTP=true
407 UseHostname=true
408 SendHostname=true
409 UseDomains=true
410 )");
411
412 auto dhcp = createDHCPv4Config();
413
414 EXPECT_CALL(manager.mockReload, schedule()).Times(5);
415
416 dhcp->dnsEnabled(false);
417 dhcp->ntpEnabled(false);
418 dhcp->hostNameEnabled(false);
419 dhcp->sendHostNameEnabled(false);
420 dhcp->domainEnabled(false);
421
422 EXPECT_FALSE(dhcp->dnsEnabled());
423 EXPECT_FALSE(dhcp->ntpEnabled());
424 EXPECT_FALSE(dhcp->hostNameEnabled());
425 EXPECT_FALSE(dhcp->sendHostNameEnabled());
426 EXPECT_FALSE(dhcp->domainEnabled());
427 }
428
TEST_F(TestDHCPConfiguration,PropertiesAreIndependent)429 TEST_F(TestDHCPConfiguration, PropertiesAreIndependent)
430 {
431 auto dhcp = createDHCPv4Config();
432
433 EXPECT_CALL(manager.mockReload, schedule()).Times(0);
434
435 dhcp->dnsEnabled(true);
436 dhcp->ntpEnabled(true);
437
438 EXPECT_TRUE(dhcp->dnsEnabled());
439 EXPECT_TRUE(dhcp->ntpEnabled());
440 EXPECT_TRUE(dhcp->hostNameEnabled());
441 EXPECT_TRUE(dhcp->sendHostNameEnabled());
442 EXPECT_TRUE(dhcp->domainEnabled());
443 }
444
445 } // namespace dhcp
446 } // namespace network
447 } // namespace phosphor
448