picnoir
/
Systemd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Systemd/test/test-network/systemd-networkd-tests.py

2593 lines
108 KiB
Python
Raw Normal View History

test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
#!/usr/bin/env python3
# SPDX-License-Identifier: LGPL-2.1+
# systemd-networkd tests
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
import argparse
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
import os
tests: also use lsmod to check whether modules are available (#10634) It's not entirely impossible to screw something up playing with kernel modules on a Saturday evening :-) This PR fixes a scenario where a module has been loaded into the kernel but the module itself has been removed from the disk. ``` $ lsmod | grep wireg wireguard 225280 0 ip6_udp_tunnel 16384 1 wireguard udp_tunnel 16384 1 wireguard $ modprobe wireguard modprobe: FATAL: Module wireguard not found in directory /lib/modules/4.18.16-200.fc28.x86_64 $ sudo ./systemd-networkd-tests.py NetworkdNetDevTests.test_wireguard ... modprobe: FATAL: Module wireguard not found in directory /lib/modules/4.18.16-200.fc28.x86_64 test_wireguard (__main__.NetworkdNetDevTests) ... unexpected success ---------------------------------------------------------------------- Ran 1 test in 5.152s FAILED (unexpected successes=1) ``` This is a follow-up to https://github.com/systemd/systemd/pull/10625.
2018-11-05 04:47:38 +01:00
import re
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
import shutil
import signal
test-network: sort imported modules
2018-12-06 14:59:49 +01:00
import subprocess
import sys
import time
import unittest
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
from shutil import copytree
test-network: use /run instead of legacy /var/run
2018-11-28 19:55:01 +01:00
network_unit_file_path='/run/systemd/network'
test-network: clear state file before starting networkd Otherwise, some tests may disturb others, e.g., NetworkdNetWorkTests.test_routing_policy_rule_port_range and NetworkdNetWorkTests.test_routing_policy_rule.
2018-11-28 20:03:56 +01:00
networkd_runtime_directory='/run/systemd/netif'
test-network: use /run instead of legacy /var/run
2018-11-28 19:55:01 +01:00
networkd_ci_path='/run/networkd-ci'
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
network_sysctl_ipv6_path='/proc/sys/net/ipv6/conf'
network_sysctl_ipv4_path='/proc/sys/net/ipv4/conf'
test-network: use /run instead of legacy /var/run
2018-11-28 19:55:01 +01:00
dnsmasq_pid_file='/run/networkd-ci/test-test-dnsmasq.pid'
dnsmasq_log_file='/run/networkd-ci/test-dnsmasq-log-file'
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
networkd_bin='/usr/lib/systemd/systemd-networkd'
test-network: add wait_online() helper function
2019-03-21 21:06:09 +01:00
wait_online_bin='/usr/lib/systemd/systemd-networkd-wait-online'
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
networkctl_bin='/usr/bin/networkctl'
use_valgrind=False
enable_debug=False
env = {}
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
asan_options=None
test-network: add --lsan-options option
2019-05-31 01:49:48 +02:00
lsan_options=None
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
ubsan_options=None
test-network: add wait_online() helper function
2019-03-21 21:06:09 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
def check_output(*command, **kwargs):
# This replaces both check_output and check_call (output can be ignored)
command = command[0].split() + list(command[1:])
return subprocess.check_output(command, universal_newlines=True, **kwargs).rstrip()
def call(*command, **kwargs):
command = command[0].split() + list(command[1:])
return subprocess.call(command, universal_newlines=True, **kwargs)
def run(*command, **kwargs):
command = command[0].split() + list(command[1:])
return subprocess.run(command, universal_newlines=True, **kwargs)
tests: mark a few tests as expected failures when the required modules aren't available Closes https://github.com/systemd/systemd/issues/10617.
2018-11-02 22:08:30 +01:00
def is_module_available(module_name):
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
lsmod_output = check_output('lsmod')
module_re = re.compile(rf'^{re.escape(module_name)}\b', re.MULTILINE)
return module_re.search(lsmod_output) or not call('modprobe', module_name)
tests: mark a few tests as expected failures when the required modules aren't available Closes https://github.com/systemd/systemd/issues/10617.
2018-11-02 22:08:30 +01:00
def expectedFailureIfModuleIsNotAvailable(module_name):
def f(func):
if not is_module_available(module_name):
return unittest.expectedFailure(func)
return func
return f
test-network: skip erspan test if not available
2019-01-30 12:52:37 +01:00
def expectedFailureIfERSPANModuleIsNotAvailable():
def f(func):
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
rc = call('ip link add dev erspan99 type erspan seq key 30 local 192.168.1.4 remote 192.168.1.1 erspan_ver 1 erspan 123')
test-network: skip erspan test if not available
2019-01-30 12:52:37 +01:00
if rc == 0:
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip link del erspan99')
test-network: skip erspan test if not available
2019-01-30 12:52:37 +01:00
return func
else:
return unittest.expectedFailure(func)
return f
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
def expectedFailureIfRoutingPolicyPortRangeIsNotAvailable():
def f(func):
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
rc = call('ip rule add from 192.168.100.19 sport 1123-1150 dport 3224-3290 table 7')
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
if rc == 0:
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip rule del from 192.168.100.19 sport 1123-1150 dport 3224-3290 table 7')
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
return func
else:
return unittest.expectedFailure(func)
return f
def expectedFailureIfRoutingPolicyIPProtoIsNotAvailable():
def f(func):
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
rc = call('ip rule add not from 192.168.100.19 ipproto tcp table 7')
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
if rc == 0:
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip rule del not from 192.168.100.19 ipproto tcp table 7')
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
return func
else:
return unittest.expectedFailure(func)
return f
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
def expectedFailureIfEthtoolDoesNotSupportDriver():
def f(func):
support = False
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
rc = call('ip link add name dummy99 type dummy')
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
if rc == 0:
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
ret = run('udevadm info -w10s /sys/class/net/dummy99', stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
if ret.returncode == 0 and 'E: ID_NET_DRIVER=dummy' in ret.stdout.rstrip():
support = True
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip link del dummy99')
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
if support:
return func
else:
return unittest.expectedFailure(func)
return f
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUpModule():
os.makedirs(network_unit_file_path, exist_ok=True)
os.makedirs(networkd_ci_path, exist_ok=True)
shutil.rmtree(networkd_ci_path)
test: make systemd-networkd-tests.py run on arbitrary directory
2018-10-03 07:38:30 +02:00
copytree(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'conf'), networkd_ci_path)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('systemctl stop systemd-networkd.socket')
check_output('systemctl stop systemd-networkd.service')
test-network: stop systemd-networkd.socket during testing To suppress noisy warning messages.
2018-11-28 22:00:19 +01:00
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
drop_in = [
'[Service]',
'Restart=no',
'ExecStart=',
]
if use_valgrind:
drop_in += [
'ExecStart=!!valgrind --track-origins=yes --leak-check=full --show-leak-kinds=all ' + networkd_bin,
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
'PrivateTmp=yes'
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
]
else:
drop_in += ['ExecStart=!!' + networkd_bin]
if enable_debug:
drop_in += ['Environment=SYSTEMD_LOG_LEVEL=debug']
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
if asan_options:
drop_in += ['Environment=ASAN_OPTIONS="' + asan_options + '"']
test-network: add --lsan-options option
2019-05-31 01:49:48 +02:00
if lsan_options:
drop_in += ['Environment=LSAN_OPTIONS="' + lsan_options + '"']
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
if ubsan_options:
drop_in += ['Environment=UBSAN_OPTIONS="' + ubsan_options + '"']
test-network: disable SystemCallFilter= when *SAN is enabled
2019-06-01 08:55:16 +02:00
if asan_options or lsan_options or ubsan_options:
drop_in += ['SystemCallFilter=']
test-network: add --lsan-options option
2019-05-31 01:49:48 +02:00
if use_valgrind or asan_options or lsan_options or ubsan_options:
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
drop_in += ['MemoryDenyWriteExecute=no']
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
os.makedirs('/run/systemd/system/systemd-networkd.service.d', exist_ok=True)
with open('/run/systemd/system/systemd-networkd.service.d/00-override.conf', mode='w') as f:
test-network: show systemd-networkd.service As there may exist some other drop-in configs.
2019-05-31 06:54:08 +02:00
f.write('\n'.join(drop_in))
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('systemctl daemon-reload')
print(check_output('systemctl cat systemd-networkd.service'))
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDownModule():
shutil.rmtree(networkd_ci_path)
test-network: stop service before editing unit file
2019-05-31 02:52:27 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('systemctl stop systemd-networkd.service')
test-network: stop service before editing unit file
2019-05-31 02:52:27 +02:00
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
shutil.rmtree('/run/systemd/system/systemd-networkd.service.d')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('systemctl daemon-reload')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('systemctl start systemd-networkd.socket')
check_output('systemctl start systemd-networkd.service')
test-network: stop systemd-networkd.socket during testing To suppress noisy warning messages.
2018-11-28 22:00:19 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
def read_link_attr(link, dev, attribute):
with open(os.path.join(os.path.join(os.path.join('/sys/class/net/', link), dev), attribute)) as f:
return f.readline().strip()
def read_bridge_port_attr(bridge, link, attribute):
path_bridge = os.path.join('/sys/devices/virtual/net', bridge)
path_port = 'lower_' + link + '/brport'
path = os.path.join(path_bridge, path_port)
with open(os.path.join(path, attribute)) as f:
return f.readline().strip()
def link_exists(link):
return os.path.exists(os.path.join('/sys/class/net', link))
def remove_links(links):
for link in links:
if link_exists(link):
call('ip link del dev', link)
time.sleep(1)
def remove_fou_ports(ports):
for port in ports:
test-network: suppress error message in cleanup process
2019-06-14 09:45:50 +02:00
call('ip fou del port', port, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
def remove_routing_policy_rule_tables(tables):
for table in tables:
test-network: suppress error message in cleanup process
2019-06-14 09:45:50 +02:00
call('ip rule del table', table, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
def remove_routes(routes):
for route_type, addr in routes:
test-network: suppress error message in cleanup process
2019-06-14 09:45:50 +02:00
call('ip route del', route_type, addr, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
def l2tp_tunnel_remove(tunnel_ids):
output = check_output('ip l2tp show tunnel')
for tid in tunnel_ids:
words='Tunnel ' + tid + ', encap'
if words in output:
call('ip l2tp del tunnel tid', tid)
time.sleep(1)
def read_ipv6_sysctl_attr(link, attribute):
with open(os.path.join(os.path.join(network_sysctl_ipv6_path, link), attribute)) as f:
return f.readline().strip()
def read_ipv4_sysctl_attr(link, attribute):
with open(os.path.join(os.path.join(network_sysctl_ipv4_path, link), attribute)) as f:
return f.readline().strip()
def copy_unit_to_networkd_unit_path(*units):
print()
for unit in units:
shutil.copy(os.path.join(networkd_ci_path, unit), network_unit_file_path)
if (os.path.exists(os.path.join(networkd_ci_path, unit + '.d'))):
copytree(os.path.join(networkd_ci_path, unit + '.d'), os.path.join(network_unit_file_path, unit + '.d'))
def remove_unit_from_networkd_path(units):
for unit in units:
if (os.path.exists(os.path.join(network_unit_file_path, unit))):
os.remove(os.path.join(network_unit_file_path, unit))
if (os.path.exists(os.path.join(network_unit_file_path, unit + '.d'))):
shutil.rmtree(os.path.join(network_unit_file_path, unit + '.d'))
def warn_about_firewalld():
rc = call('systemctl -q is-active firewalld.service')
if rc == 0:
print('\nWARNING: firewalld.service is active. The test may fail.')
def start_dnsmasq(additional_options='', ipv4_range='192.168.5.10,192.168.5.200', ipv6_range='2600::10,2600::20', lease_time='1h'):
warn_about_firewalld()
dnsmasq_command = f'dnsmasq -8 /var/run/networkd-ci/test-dnsmasq-log-file --log-queries=extra --log-dhcp --pid-file=/var/run/networkd-ci/test-test-dnsmasq.pid --conf-file=/dev/null --interface=veth-peer --enable-ra --dhcp-range={ipv6_range},{lease_time} --dhcp-range={ipv4_range},{lease_time} -R --dhcp-leasefile=/var/run/networkd-ci/lease --dhcp-option=26,1492 --dhcp-option=option:router,192.168.5.1 --dhcp-option=33,192.168.5.4,192.168.5.5 --port=0 ' + additional_options
check_output(dnsmasq_command)
def stop_dnsmasq(pid_file):
if os.path.exists(pid_file):
with open(pid_file, 'r') as f:
pid = f.read().rstrip(' \t\r\n\0')
os.kill(int(pid), signal.SIGTERM)
os.remove(pid_file)
def search_words_in_dnsmasq_log(words, show_all=False):
if os.path.exists(dnsmasq_log_file):
with open (dnsmasq_log_file) as in_file:
contents = in_file.read()
if show_all:
print(contents)
for line in contents.splitlines():
if words in line:
in_file.close()
print("%s, %s" % (words, line))
return True
return False
def remove_lease_file():
if os.path.exists(os.path.join(networkd_ci_path, 'lease')):
os.remove(os.path.join(networkd_ci_path, 'lease'))
def remove_log_file():
if os.path.exists(dnsmasq_log_file):
os.remove(dnsmasq_log_file)
def start_networkd(sleep_sec=5, remove_state_files=True):
if (remove_state_files and
os.path.exists(os.path.join(networkd_runtime_directory, 'state'))):
check_output('systemctl stop systemd-networkd')
os.remove(os.path.join(networkd_runtime_directory, 'state'))
check_output('systemctl start systemd-networkd')
else:
check_output('systemctl restart systemd-networkd')
if sleep_sec > 0:
time.sleep(sleep_sec)
def wait_online(links_with_operstate, timeout='20s', bool_any=False):
args = wait_online_cmd + [f'--timeout={timeout}'] + [f'--interface={link}' for link in links_with_operstate]
if bool_any:
args += ['--any']
try:
check_output(*args, env=env)
except subprocess.CalledProcessError:
for link in links_with_operstate:
output = check_output(*networkctl_cmd, 'status', link.split(':')[0], env=env)
print(output)
raise
test-network: add test for bridge MulticastToUnicast
2018-12-06 07:24:14 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
def get_operstate(link, show_status=True, setup_state='configured'):
output = check_output(*networkctl_cmd, 'status', link, env=env)
if show_status:
print(output)
for line in output.splitlines():
if 'State:' in line and (not setup_state or setup_state in line):
return line.split()[1]
return None
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
class Utilities():
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
def check_link_exists(self, link):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertTrue(link_exists(link))
test-network: add get_operstate() and check_operstate() helper functions
2019-05-15 11:25:30 +02:00
def check_operstate(self, link, expected, show_status=True, setup_state='configured'):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertRegex(get_operstate(link, show_status, setup_state), expected)
test-network: add get_operstate() and check_operstate() helper functions
2019-05-15 11:25:30 +02:00
test-network: bump time limit for wait_address() Maximum time interval of DHCPv4 request is 63sec. So, setting 100sec is enough.
2019-05-29 05:07:36 +02:00
def wait_address(self, link, address_regex, scope='global', ipv='', timeout_sec=100):
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
for i in range(timeout_sec):
if i > 0:
time.sleep(1)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(f'ip {ipv} address show dev {link} scope {scope}')
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
if re.search(address_regex, output):
break
else:
self.assertRegex(output, address_regex)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
class NetworkctlTests(unittest.TestCase, Utilities):
links = [
'test1',
'veth99',
]
units = [
'11-dummy.netdev',
test-network: add test for MTU field of 'networkctl status'
2019-06-01 08:44:04 +02:00
'11-dummy-mtu.netdev',
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
'11-dummy.network',
'25-veth.netdev',
'netdev-link-local-addressing-yes.network',
]
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
def test_glob(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '11-dummy.network')
start_networkd(0)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:degraded'])
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'list', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertRegex(output, '1 lo ')
self.assertRegex(output, 'test1')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'list', 'test1', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertNotRegex(output, '1 lo ')
self.assertRegex(output, 'test1')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'list', 'te*', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertNotRegex(output, '1 lo ')
self.assertRegex(output, 'test1')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'te*', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertNotRegex(output, '1: lo ')
self.assertRegex(output, 'test1')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'tes[a-z][0-9]', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertNotRegex(output, '1: lo ')
self.assertRegex(output, 'test1')
test-network: add test for MTU field of 'networkctl status'
2019-06-01 08:44:04 +02:00
def test_mtu(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy-mtu.netdev', '11-dummy.network')
start_networkd(0)
test-network: add test for MTU field of 'networkctl status'
2019-06-01 08:44:04 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:degraded'])
test-network: add test for MTU field of 'networkctl status'
2019-06-01 08:44:04 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'test1', env=env)
test-network: add test for MTU field of 'networkctl status'
2019-06-01 08:44:04 +02:00
self.assertRegex(output, 'MTU: 1600')
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
@expectedFailureIfEthtoolDoesNotSupportDriver()
def test_udev_driver(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '11-dummy.network',
'25-veth.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:degraded', 'veth99:degraded', 'veth-peer:degraded'])
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'test1', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertRegex(output, 'Driver: dummy')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertRegex(output, 'Driver: veth')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth-peer', env=env)
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
self.assertRegex(output, 'Driver: veth')
test-network: add get_operstate() and check_operstate() helper functions
2019-05-15 11:25:30 +02:00
test-network: add tests for "networkctl delete"
2019-05-31 09:11:53 +02:00
def test_delete_links(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '11-dummy.network',
'25-veth.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test-network: add tests for "networkctl delete"
2019-05-31 09:11:53 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:degraded', 'veth99:degraded', 'veth-peer:degraded'])
test-network: add tests for "networkctl delete"
2019-05-31 09:11:53 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output(*networkctl_cmd, 'delete', 'test1', 'veth99')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertFalse(link_exists('test1'))
self.assertFalse(link_exists('veth99'))
self.assertFalse(link_exists('veth-peer'))
test-network: add tests for "networkctl delete"
2019-05-31 09:11:53 +02:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
class NetworkdNetDevTests(unittest.TestCase, Utilities):
test-network: sort links and units
2018-12-06 14:57:20 +01:00
links =[
'6rdtun99',
'bond99',
'bridge99',
'dropin-test',
'dummy98',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'erspan98',
'erspan99',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'geneve99',
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
'gretap96',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'gretap98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'gretap99',
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
'gretun96',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'gretun97',
'gretun98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'gretun99',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'ip6gretap98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'ip6gretap99',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'ip6gretun97',
'ip6gretun98',
'ip6gretun99',
'ip6tnl97',
'ip6tnl98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'ip6tnl99',
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
'ipiptun96',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'ipiptun97',
'ipiptun98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'ipiptun99',
'ipvlan99',
test-network: add a basic test for ipvtap
2019-05-16 02:48:34 +02:00
'ipvtap99',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'isataptun99',
'macvlan99',
'macvtap99',
test-network: add a basic test for nlmon
2019-05-23 04:37:53 +02:00
'nlmon99',
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
'sittun96',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'sittun97',
'sittun98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'sittun99',
'tap99',
'test1',
'tun99',
'vcan99',
'veth99',
'vlan99',
'vrf99',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'vti6tun97',
'vti6tun98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'vti6tun99',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'vtitun97',
'vtitun98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'vtitun99',
test-network: add basic tests for vxcan device
2019-05-23 17:51:22 +02:00
'vxcan99',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'vxlan99',
test: add a testcase for 23 wirguard peers
2019-01-14 02:06:21 +01:00
'wg98',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'wg99']
units = [
'10-dropin-test.netdev',
'11-dummy.netdev',
test-network: add tests for --any option of wait-online
2019-04-01 03:28:32 +02:00
'11-dummy.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'12-dummy.netdev',
test-network: add test for NetDev.Name= conflict
2019-03-31 18:06:22 +02:00
'15-name-conflict-test.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'21-macvlan.netdev',
'21-macvtap.netdev',
test-network: add tests for issue #11921
2019-03-08 04:34:56 +01:00
'21-vlan-test1.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'21-vlan.netdev',
'21-vlan.network',
'25-6rd-tunnel.netdev',
'25-bond.netdev',
netdev bond: add support to configure tlb_dynamic_lb Closes https://github.com/systemd/systemd/issues/11135 Add test for bond : tlb_dynamic_lb
2018-12-13 10:23:07 +01:00
'25-bond-balanced-tlb.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-bridge.netdev',
test-network: add tests for --any option of wait-online
2019-04-01 03:28:32 +02:00
'25-bridge.network',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-erspan-tunnel-local-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-erspan-tunnel.netdev',
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
'25-fou-gretap.netdev',
'25-fou-gre.netdev',
'25-fou-ipip.netdev',
'25-fou-ipproto-gre.netdev',
'25-fou-ipproto-ipip.netdev',
'25-fou-sit.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-geneve.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-gretap-tunnel-local-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-gretap-tunnel.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-gre-tunnel-local-any.netdev',
'25-gre-tunnel-remote-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-gre-tunnel.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-ip6gretap-tunnel-local-any.netdev',
'25-ip6gretap-tunnel.netdev',
'25-ip6gre-tunnel-local-any.netdev',
'25-ip6gre-tunnel-remote-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-ip6gre-tunnel.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-ip6tnl-tunnel-remote-any.netdev',
'25-ip6tnl-tunnel-local-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-ip6tnl-tunnel.netdev',
'25-ipip-tunnel-independent.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-ipip-tunnel-local-any.netdev',
'25-ipip-tunnel-remote-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-ipip-tunnel.netdev',
'25-ipvlan.netdev',
test-network: add a basic test for ipvtap
2019-05-16 02:48:34 +02:00
'25-ipvtap.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-isatap-tunnel.netdev',
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
'25-macsec.key',
'25-macsec.netdev',
'25-macsec.network',
test-network: add a basic test for nlmon
2019-05-23 04:37:53 +02:00
'25-nlmon.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-sit-tunnel-local-any.netdev',
'25-sit-tunnel-remote-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-sit-tunnel.netdev',
'25-tap.netdev',
'25-tun.netdev',
test-network: check tunnel netdevs become operstate 'routable'
2019-05-12 23:55:16 +02:00
'25-tunnel-local-any.network',
'25-tunnel-remote-any.network',
'25-tunnel.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-vcan.netdev',
'25-veth.netdev',
'25-vrf.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-vti6-tunnel-local-any.netdev',
'25-vti6-tunnel-remote-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-vti6-tunnel.netdev',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'25-vti-tunnel-local-any.netdev',
'25-vti-tunnel-remote-any.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-vti-tunnel.netdev',
test-network: add basic tests for vxcan device
2019-05-23 17:51:22 +02:00
'25-vxcan.netdev',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-vxlan.netdev',
test: add a testcase for 23 wirguard peers
2019-01-14 02:06:21 +01:00
'25-wireguard-23-peers.netdev',
'25-wireguard-23-peers.network',
test-network: add tests for WireGuardPeer.PresharedKey= and PresharedKeyFile=
2019-04-05 10:52:29 +02:00
'25-wireguard-preshared-key.txt',
test-network: add test for WireGuard.PrivateKeyFile=
2019-03-04 06:42:03 +01:00
'25-wireguard-private-key.txt',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-wireguard.netdev',
test-network: add test for drop-in [WireGuardPeer] section This also merges the two wireguard tests, and use wait_online() to speed up the test.
2019-03-31 16:56:39 +02:00
'25-wireguard.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'6rd.network',
test-network: test stacked erspan tunnels
2019-03-29 19:50:11 +01:00
'erspan.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'gre.network',
'gretap.network',
'gretun.network',
'ip6gretap.network',
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
'ip6gretun.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'ip6tnl.network',
'ipip.network',
'ipvlan.network',
test-network: add a basic test for ipvtap
2019-05-16 02:48:34 +02:00
'ipvtap.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'isatap.network',
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
'macsec.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'macvlan.network',
'macvtap.network',
test-network: add tests for LinkLocalAddressing= on ipvlan or friends
2019-05-20 06:16:55 +02:00
'netdev-link-local-addressing-yes.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'sit.network',
'vti6.network',
'vti.network',
test-network: add tests for BridgeFDB.Destination=
2019-05-03 06:08:55 +02:00
'vxlan-test1.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'vxlan.network']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: remove fou ports on failure
2019-05-24 06:39:50 +02:00
fou_ports = [
'55555',
'55556']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_fou_ports(self.fou_ports)
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_fou_ports(self.fou_ports)
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: move networkctl related tests to NetworkctlTests class
2019-06-01 03:29:08 +02:00
def test_dropin_and_name_conflict(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('10-dropin-test.netdev', '15-name-conflict-test.netdev')
start_networkd(0)
test-network: add one more test for netdev dropin .conf files For netdev, config files are loaded twice, and the first time, only Match and NetDev setions are read. So, the test given by the previous commit covers only the second loading. This adds another test that also covers the first loading.
2018-11-26 14:05:48 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['dropin-test:off'])
test-network: add one more test for netdev dropin .conf files For netdev, config files are loaded twice, and the first time, only Match and NetDev setions are read. So, the test given by the previous commit covers only the second loading. This adds another test that also covers the first loading.
2018-11-26 14:05:48 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip link show dropin-test')
test-network: add one more test for netdev dropin .conf files For netdev, config files are loaded twice, and the first time, only Match and NetDev setions are read. So, the test given by the previous commit covers only the second loading. This adds another test that also covers the first loading.
2018-11-26 14:05:48 +01:00
print(output)
self.assertRegex(output, '00:50:56:c0:00:28')
test-network: add tests for --any option of wait-online
2019-04-01 03:28:32 +02:00
def test_wait_online_any(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-bridge.netdev', '25-bridge.network', '11-dummy.netdev', '11-dummy.network')
start_networkd(0)
test-network: add tests for --any option of wait-online
2019-04-01 03:28:32 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['bridge99', 'test1:degraded'], bool_any=True)
test-network: add tests for --any option of wait-online
2019-04-01 03:28:32 +02:00
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('bridge99', '(?:off|no-carrier)', setup_state='configuring')
self.check_operstate('test1', 'degraded')
test-network: add tests for --any option of wait-online
2019-04-01 03:28:32 +02:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_bridge(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-bridge.netdev')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['bridge99:off'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: convert jiffies to sec
2019-05-20 03:43:50 +02:00
tick = os.sysconf('SC_CLK_TCK')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'hello_time')) / tick))
self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'max_age')) / tick))
self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge','forward_delay')) / tick))
self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge','ageing_time')) / tick))
self.assertEqual(9, int(read_link_attr('bridge99', 'bridge','priority')))
self.assertEqual(1, int(read_link_attr('bridge99', 'bridge','multicast_querier')))
self.assertEqual(1, int(read_link_attr('bridge99', 'bridge','multicast_snooping')))
self.assertEqual(1, int(read_link_attr('bridge99', 'bridge','stp_state')))
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_bond(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-bond.netdev', '25-bond-balanced-tlb.netdev')
start_networkd(0)
wait_online(['bond99:off', 'bond98:off'])
self.assertEqual('802.3ad 4', read_link_attr('bond99', 'bonding', 'mode'))
self.assertEqual('layer3+4 1', read_link_attr('bond99', 'bonding', 'xmit_hash_policy'))
self.assertEqual('1000', read_link_attr('bond99', 'bonding', 'miimon'))
self.assertEqual('fast 1', read_link_attr('bond99', 'bonding', 'lacp_rate'))
self.assertEqual('2000', read_link_attr('bond99', 'bonding', 'updelay'))
self.assertEqual('2000', read_link_attr('bond99', 'bonding', 'downdelay'))
self.assertEqual('4', read_link_attr('bond99', 'bonding', 'resend_igmp'))
self.assertEqual('1', read_link_attr('bond99', 'bonding', 'min_links'))
self.assertEqual('1218', read_link_attr('bond99', 'bonding', 'ad_actor_sys_prio'))
self.assertEqual('811', read_link_attr('bond99', 'bonding', 'ad_user_port_key'))
self.assertEqual('00:11:22:33:44:55', read_link_attr('bond99', 'bonding', 'ad_actor_system'))
self.assertEqual('balance-tlb 5', read_link_attr('bond98', 'bonding', 'mode'))
self.assertEqual('1', read_link_attr('bond98', 'bonding', 'tlb_dynamic_lb'))
netdev bond: add support to configure tlb_dynamic_lb Closes https://github.com/systemd/systemd/issues/11135 Add test for bond : tlb_dynamic_lb
2018-12-13 10:23:07 +01:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_vlan(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('21-vlan.netdev', '11-dummy.netdev',
'21-vlan.network', '21-vlan-test1.network')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:degraded', 'vlan99:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show test1')
test-network: add test for MTUBytes= in vlan or macvlan devices
2019-02-23 11:25:01 +01:00
print(output)
test-network: adjust mtu
2019-05-16 04:49:13 +02:00
self.assertRegex(output, ' mtu 2000 ')
test-network: add test for MTUBytes= in vlan or macvlan devices
2019-02-23 11:25:01 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vlan99')
test-network: show command outputs
2018-12-06 15:12:28 +01:00
print(output)
test-network: fix invalid assertions
2019-04-25 00:29:20 +02:00
self.assertRegex(output, ' mtu 2000 ')
self.assertRegex(output, 'REORDER_HDR')
self.assertRegex(output, 'LOOSE_BINDING')
self.assertRegex(output, 'GVRP')
self.assertRegex(output, 'MVRP')
self.assertRegex(output, ' id 99 ')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev test1')
test-network: add tests for issue #11921
2019-03-08 04:34:56 +01:00
print(output)
self.assertRegex(output, 'inet 192.168.24.5/24 brd 192.168.24.255 scope global test1')
self.assertRegex(output, 'inet 192.168.25.5/24 brd 192.168.25.255 scope global test1')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev vlan99')
test-network: add tests for issue #11921
2019-03-08 04:34:56 +01:00
print(output)
self.assertRegex(output, 'inet 192.168.23.5/24 brd 192.168.23.255 scope global vlan99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_macvtap(self):
test-network: add tests for Mode= setting in [MACVTAP] section
2019-05-20 04:47:24 +02:00
for mode in ['private', 'vepa', 'bridge', 'passthru']:
with self.subTest(mode=mode):
if mode != 'private':
self.tearDown()
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('21-macvtap.netdev', 'netdev-link-local-addressing-yes.network',
'11-dummy.netdev', 'macvtap.network')
test-network: add tests for Mode= setting in [MACVTAP] section
2019-05-20 04:47:24 +02:00
with open(os.path.join(network_unit_file_path, '21-macvtap.netdev'), mode='a') as f:
f.write('[MACVTAP]\nMode=' + mode)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['macvtap99:degraded', 'test1:degraded'])
test-network: add tests for Mode= setting in [MACVTAP] section
2019-05-20 04:47:24 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show macvtap99')
test-network: add tests for Mode= setting in [MACVTAP] section
2019-05-20 04:47:24 +02:00
print(output)
self.assertRegex(output, 'macvtap mode ' + mode + ' ')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_macvlan(self):
test-network: add tests for Mode= setting in [MACVLAN] section
2019-05-20 04:39:05 +02:00
for mode in ['private', 'vepa', 'bridge', 'passthru']:
with self.subTest(mode=mode):
if mode != 'private':
self.tearDown()
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('21-macvlan.netdev', 'netdev-link-local-addressing-yes.network',
'11-dummy.netdev', 'macvlan.network')
test-network: add tests for Mode= setting in [MACVLAN] section
2019-05-20 04:39:05 +02:00
with open(os.path.join(network_unit_file_path, '21-macvlan.netdev'), mode='a') as f:
f.write('[MACVLAN]\nMode=' + mode)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
test-network: add tests for Mode= setting in [MACVLAN] section
2019-05-20 04:39:05 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['macvlan99:degraded', 'test1:degraded'])
test-network: add tests for Mode= setting in [MACVLAN] section
2019-05-20 04:39:05 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show test1')
test-network: add tests for Mode= setting in [MACVLAN] section
2019-05-20 04:39:05 +02:00
print(output)
self.assertRegex(output, ' mtu 2000 ')
test-network: add test for MTUBytes= in vlan or macvlan devices
2019-02-23 11:25:01 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show macvlan99')
test-network: add tests for Mode= setting in [MACVLAN] section
2019-05-20 04:39:05 +02:00
print(output)
self.assertRegex(output, ' mtu 2000 ')
self.assertRegex(output, 'macvlan mode ' + mode + ' ')
test-network: add test for MTUBytes= in vlan or macvlan devices
2019-02-23 11:25:01 +01:00
tests: mark a few tests as expected failures when the required modules aren't available Closes https://github.com/systemd/systemd/issues/10617.
2018-11-02 22:08:30 +01:00
@expectedFailureIfModuleIsNotAvailable('ipvlan')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_ipvlan(self):
test-network: add tests for Flags= in [IPVLAN]
2019-05-20 05:47:31 +02:00
for mode, flag in [['L2', 'private'], ['L3', 'vepa'], ['L3S', 'bridge']]:
with self.subTest(mode=mode, flag=flag):
if mode != 'L2':
self.tearDown()
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-ipvlan.netdev', 'netdev-link-local-addressing-yes.network',
'11-dummy.netdev', 'ipvlan.network')
test-network: add tests for Flags= in [IPVLAN]
2019-05-20 05:47:31 +02:00
with open(os.path.join(network_unit_file_path, '25-ipvlan.netdev'), mode='a') as f:
f.write('[IPVLAN]\nMode=' + mode + '\nFlags=' + flag)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['ipvlan99:degraded', 'test1:degraded'])
test-network: add tests for Flags= in [IPVLAN]
2019-05-20 05:47:31 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ipvlan99')
test-network: add tests for Flags= in [IPVLAN]
2019-05-20 05:47:31 +02:00
print(output)
self.assertRegex(output, 'ipvlan *mode ' + mode.lower() + ' ' + flag)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add a basic test for ipvtap
2019-05-16 02:48:34 +02:00
@expectedFailureIfModuleIsNotAvailable('ipvtap')
def test_ipvtap(self):
test-network: add tests for Flags= in [IPVTAP]
2019-05-20 05:48:05 +02:00
for mode, flag in [['L2', 'private'], ['L3', 'vepa'], ['L3S', 'bridge']]:
with self.subTest(mode=mode, flag=flag):
if mode != 'L2':
self.tearDown()
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-ipvtap.netdev', 'netdev-link-local-addressing-yes.network',
'11-dummy.netdev', 'ipvtap.network')
test-network: add tests for Flags= in [IPVTAP]
2019-05-20 05:48:05 +02:00
with open(os.path.join(network_unit_file_path, '25-ipvtap.netdev'), mode='a') as f:
f.write('[IPVTAP]\nMode=' + mode + '\nFlags=' + flag)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['ipvtap99:degraded', 'test1:degraded'])
test-network: add a basic test for ipvtap
2019-05-16 02:48:34 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ipvtap99')
test-network: add tests for Flags= in [IPVTAP]
2019-05-20 05:48:05 +02:00
print(output)
self.assertRegex(output, 'ipvtap *mode ' + mode.lower() + ' ' + flag)
test-network: add a basic test for ipvtap
2019-05-16 02:48:34 +02:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_veth(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['veth99:degraded', 'veth-peer:degraded'])
test-network: add basic tests for veth interfaces
2019-05-20 08:29:54 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show veth99')
test-network: add basic tests for veth interfaces
2019-05-20 08:29:54 +02:00
print(output)
self.assertRegex(output, 'link/ether 12:34:56:78:9a:bc')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show veth-peer')
test-network: add basic tests for veth interfaces
2019-05-20 08:29:54 +02:00
print(output)
self.assertRegex(output, 'link/ether 12:34:56:78:9a:bd')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_tun(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-tun.netdev')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['tun99:off'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show tun99')
test-network: add tests for flags of tun or tap devices
2019-05-20 06:59:34 +02:00
print(output)
# Old ip command does not support IFF_ flags
self.assertRegex(output, 'tun (?:type tun pi on vnet_hdr on multi_queue|addrgenmode) ')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_tap(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-tap.netdev')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['tap99:off'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show tap99')
test-network: add tests for flags of tun or tap devices
2019-05-20 06:59:34 +02:00
print(output)
# Old ip command does not support IFF_ flags
self.assertRegex(output, 'tun (?:type tap pi on vnet_hdr on multi_queue|addrgenmode) ')
tests: mark a few tests as expected failures when the required modules aren't available Closes https://github.com/systemd/systemd/issues/10617.
2018-11-02 22:08:30 +01:00
@expectedFailureIfModuleIsNotAvailable('vrf')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_vrf(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-vrf.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['vrf99:carrier'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
tests: mark a few tests as expected failures when the required modules aren't available Closes https://github.com/systemd/systemd/issues/10617.
2018-11-02 22:08:30 +01:00
@expectedFailureIfModuleIsNotAvailable('vcan')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_vcan(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-vcan.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['vcan99:carrier'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add basic tests for vxcan device
2019-05-23 17:51:22 +02:00
@expectedFailureIfModuleIsNotAvailable('vxcan')
def test_vxcan(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-vxcan.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test-network: add basic tests for vxcan device
2019-05-23 17:51:22 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['vxcan99:carrier', 'vxcan-peer:carrier'])
test-network: add basic tests for vxcan device
2019-05-23 17:51:22 +02:00
tests: add a basic test for wireguard (#10631)
2018-11-03 18:03:43 +01:00
@expectedFailureIfModuleIsNotAvailable('wireguard')
def test_wireguard(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-wireguard.netdev', '25-wireguard.network',
'25-wireguard-23-peers.netdev', '25-wireguard-23-peers.network',
'25-wireguard-preshared-key.txt', '25-wireguard-private-key.txt')
start_networkd(0)
wait_online(['wg99:carrier', 'wg98:routable'])
test-network: add test for drop-in [WireGuardPeer] section This also merges the two wireguard tests, and use wait_online() to speed up the test.
2019-03-31 16:56:39 +02:00
tests: add a basic test for wireguard (#10631)
2018-11-03 18:03:43 +01:00
if shutil.which('wg'):
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('wg')
test-network: add test for drop-in [WireGuardPeer] section This also merges the two wireguard tests, and use wait_online() to speed up the test.
2019-03-31 16:56:39 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 listen-port')
test-network: fix invalid assertions
2019-04-25 00:29:20 +02:00
self.assertRegex(output, '51820')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 fwmark')
test-network: fix invalid assertions
2019-04-25 00:29:20 +02:00
self.assertRegex(output, '0x4d2')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 allowed-ips')
networkd-tests.py: properly escape pluses in regexps Python warns that '\+' is an invalid escape. We need either '\\+' or r'\+'.
2019-06-06 14:08:01 +02:00
self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48')
self.assertRegex(output, r'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tfdbc:bae2:7871:e1fe:793:8636::/96 fdbc:bae2:7871:500:e1fe:793:8636:dad1/128')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 persistent-keepalive')
networkd-tests.py: properly escape pluses in regexps Python warns that '\+' is an invalid escape. We need either '\\+' or r'\+'.
2019-06-06 14:08:01 +02:00
self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t20')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 endpoints')
networkd-tests.py: properly escape pluses in regexps Python warns that '\+' is an invalid escape. We need either '\\+' or r'\+'.
2019-06-06 14:08:01 +02:00
self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.27.3:51820')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 private-key')
networkd-tests.py: properly escape pluses in regexps Python warns that '\+' is an invalid escape. We need either '\\+' or r'\+'.
2019-06-06 14:08:01 +02:00
self.assertRegex(output, r'EEGlnEPYJV//kbvvIqxKkQwOiS\+UENyPncC4bF46ong=')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg99 preshared-keys')
networkd-tests.py: properly escape pluses in regexps Python warns that '\+' is an invalid escape. We need either '\\+' or r'\+'.
2019-06-06 14:08:01 +02:00
self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA= IIWIV17wutHv7t4cR6pOT91z6NSz/T8Arh0yaywhw3M=')
self.assertRegex(output, r'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc= cPLOy1YUrEI0EMMIycPJmOo0aTu3RZnw8bL5meVD6m0=')
tests: add a basic test for wireguard (#10631)
2018-11-03 18:03:43 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('wg show wg98 private-key')
networkd-tests.py: properly escape pluses in regexps Python warns that '\+' is an invalid escape. We need either '\\+' or r'\+'.
2019-06-06 14:08:01 +02:00
self.assertRegex(output, r'CJQUtcS9emY2fLYqDlpSZiE/QJyHkPWr\+WHtZLZ90FU=')
test: add a testcase for 23 wirguard peers
2019-01-14 02:06:21 +01:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_geneve(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-geneve.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['geneve99:degraded'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show geneve99')
test-network: show command outputs
2018-12-06 15:12:28 +01:00
print(output)
test-network: fix invalid assertions
2019-04-25 00:29:20 +02:00
self.assertRegex(output, '192.168.22.1')
self.assertRegex(output, '6082')
self.assertRegex(output, 'udpcsum')
self.assertRegex(output, 'udp6zerocsumrx')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_ipip_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ipip.network',
'25-ipip-tunnel.netdev', '25-tunnel.network',
'25-ipip-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-ipip-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
start_networkd(0)
wait_online(['ipiptun99:routable', 'ipiptun98:routable', 'ipiptun97:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ipiptun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ipip (?:ipip |)remote 192.169.224.239 local 192.168.223.238 dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ipiptun98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ipip (?:ipip |)remote 192.169.224.239 local any dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ipiptun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ipip (?:ipip |)remote any local 192.168.223.238 dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_gre_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'gretun.network',
'25-gre-tunnel.netdev', '25-tunnel.network',
'25-gre-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-gre-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
start_networkd(0)
wait_online(['gretun99:routable', 'gretun98:routable', 'gretun97:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'gre remote 10.65.223.239 local 10.65.223.238 dev dummy98')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 1.2.3.103')
self.assertRegex(output, 'okey 1.2.4.103')
self.assertRegex(output, 'iseq')
self.assertRegex(output, 'oseq')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretun98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'gre remote 10.65.223.239 local any dev dummy98')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 0.0.0.104')
self.assertRegex(output, 'okey 0.0.0.104')
self.assertNotRegex(output, 'iseq')
self.assertNotRegex(output, 'oseq')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'gre remote any local 10.65.223.238 dev dummy98')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 0.0.0.105')
self.assertRegex(output, 'okey 0.0.0.105')
self.assertNotRegex(output, 'iseq')
self.assertNotRegex(output, 'oseq')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
def test_ip6gre_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6gretun.network',
'25-ip6gre-tunnel.netdev', '25-tunnel.network',
'25-ip6gre-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-ip6gre-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
test-network: explicitly set sleep time
2019-06-14 09:47:06 +02:00
start_networkd(5)
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
test-network: drop wait_online() from test_ip6gre_tunnel()
2019-05-22 11:02:20 +02:00
# Old kernels seem not to support IPv6LL address on ip6gre tunnel, So please do not use wait_online() here.
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
self.check_link_exists('ip6gretun99')
self.check_link_exists('ip6gretun98')
self.check_link_exists('ip6gretun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6gretun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6gretun98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local any dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6gretun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6gre remote any local 2a00:ffde:4567:edde::4987 dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: check tunnel netdevs become operstate 'routable'
2019-05-12 23:55:16 +02:00
def test_gretap_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'gretap.network',
'25-gretap-tunnel.netdev', '25-tunnel.network',
'25-gretap-tunnel-local-any.netdev', '25-tunnel-local-any.network')
start_networkd(0)
wait_online(['gretap99:routable', 'gretap98:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretap99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'gretap remote 10.65.223.239 local 10.65.223.238 dev dummy98')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 0.0.0.106')
self.assertRegex(output, 'okey 0.0.0.106')
self.assertRegex(output, 'iseq')
self.assertRegex(output, 'oseq')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretap98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'gretap remote 10.65.223.239 local any dev dummy98')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 0.0.0.107')
self.assertRegex(output, 'okey 0.0.0.107')
self.assertRegex(output, 'iseq')
self.assertRegex(output, 'oseq')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_ip6gretap_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6gretap.network',
'25-ip6gretap-tunnel.netdev', '25-tunnel.network',
'25-ip6gretap-tunnel-local-any.netdev', '25-tunnel-local-any.network')
start_networkd(0)
wait_online(['ip6gretap99:routable', 'ip6gretap98:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6gretap99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6gretap98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local any dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_vti_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'vti.network',
'25-vti-tunnel.netdev', '25-tunnel.network',
'25-vti-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-vti-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
start_networkd(0)
wait_online(['vtitun99:routable', 'vtitun98:routable', 'vtitun97:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vtitun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'vti remote 10.65.223.239 local 10.65.223.238 dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vtitun98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'vti remote 10.65.223.239 local any dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vtitun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'vti remote any local 10.65.223.238 dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_vti6_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'vti6.network',
'25-vti6-tunnel.netdev', '25-tunnel.network',
'25-vti6-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-vti6-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
start_networkd(0)
wait_online(['vti6tun99:routable', 'vti6tun98:routable', 'vti6tun97:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vti6tun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'vti6 remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vti6tun98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'vti6 remote 2001:473:fece:cafe::5179 local (?:any|::) dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vti6tun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'vti6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_ip6tnl_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6tnl.network',
'25-ip6tnl-tunnel.netdev', '25-tunnel.network',
'25-ip6tnl-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-ip6tnl-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
start_networkd(0)
wait_online(['ip6tnl99:routable', 'ip6tnl98:routable', 'ip6tnl97:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6tnl99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6tnl ip6ip6 remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6tnl98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6tnl ip6ip6 remote 2001:473:fece:cafe::5179 local (?:any|::) dev dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ip6tnl97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'ip6tnl ip6ip6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_sit_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'sit.network',
'25-sit-tunnel.netdev', '25-tunnel.network',
'25-sit-tunnel-local-any.netdev', '25-tunnel-local-any.network',
'25-sit-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
start_networkd(0)
wait_online(['sittun99:routable', 'sittun98:routable', 'sittun97:routable', 'dummy98:degraded'])
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show sittun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, "sit (?:ip6ip |)remote 10.65.223.239 local 10.65.223.238 dev dummy98")
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show sittun98')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, "sit (?:ip6ip |)remote 10.65.223.239 local any dev dummy98")
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show sittun97')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, "sit (?:ip6ip |)remote any local 10.65.223.238 dev dummy98")
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add test for ISATAP
2018-12-02 15:59:13 +01:00
def test_isatap_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'isatap.network',
'25-isatap-tunnel.netdev', '25-tunnel.network')
start_networkd(0)
wait_online(['isataptun99:routable', 'dummy98:degraded'])
test-network: add test for ISATAP
2018-12-02 15:59:13 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show isataptun99')
test-network: show command outputs
2018-12-06 15:12:28 +01:00
print(output)
test-network: add test for ISATAP
2018-12-02 15:59:13 +01:00
self.assertRegex(output, "isatap ")
Add a networkd test for 6rd interface creation. Unfortunately we can't check the 6rd attribute, because it's not exposed in /sys or anywhere other than netlink... But at least we can check that networkd brings up an interface that looks right.
2018-11-09 05:44:16 +01:00
def test_6rd_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', '6rd.network',
'25-6rd-tunnel.netdev', '25-tunnel.network')
start_networkd(0)
wait_online(['sittun99:routable', 'dummy98:degraded'])
Add a networkd test for 6rd interface creation. Unfortunately we can't check the 6rd attribute, because it's not exposed in /sys or anywhere other than netlink... But at least we can check that networkd brings up an interface that looks right.
2018-11-09 05:44:16 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show sittun99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, '6rd-prefix 2602::/24')
test-network: skip erspan test if not available
2019-01-30 12:52:37 +01:00
@expectedFailureIfERSPANModuleIsNotAvailable()
networkd: Add support for ERSPAN tunnel Please see: https://patchwork.ozlabs.org/patch/800327/ ``` [NetDev] Name=erspan-test Kind=erspan [Tunnel] Independent=true ERSPANIndex=123 Local = 172.16.1.200 Remote = 172.16.1.100 Key=101 SerializeTunneledPackets=true ```
2018-11-26 12:50:09 +01:00
def test_erspan_tunnel(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', 'erspan.network',
'25-erspan-tunnel.netdev', '25-tunnel.network',
'25-erspan-tunnel-local-any.netdev', '25-tunnel-local-any.network')
start_networkd(0)
wait_online(['erspan99:routable', 'erspan98:routable', 'dummy98:degraded'])
networkd: Add support for ERSPAN tunnel Please see: https://patchwork.ozlabs.org/patch/800327/ ``` [NetDev] Name=erspan-test Kind=erspan [Tunnel] Independent=true ERSPANIndex=123 Local = 172.16.1.200 Remote = 172.16.1.100 Key=101 SerializeTunneledPackets=true ```
2018-11-26 12:50:09 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show erspan99')
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
print(output)
self.assertRegex(output, 'erspan remote 172.16.1.100 local 172.16.1.200')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 0.0.0.101')
self.assertRegex(output, 'okey 0.0.0.101')
self.assertRegex(output, 'iseq')
self.assertRegex(output, 'oseq')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show erspan98')
networkd: Add support for ERSPAN tunnel Please see: https://patchwork.ozlabs.org/patch/800327/ ``` [NetDev] Name=erspan-test Kind=erspan [Tunnel] Independent=true ERSPANIndex=123 Local = 172.16.1.200 Remote = 172.16.1.100 Key=101 SerializeTunneledPackets=true ```
2018-11-26 12:50:09 +01:00
print(output)
test-network: add more tests for tunneling devices
2019-03-21 17:48:49 +01:00
self.assertRegex(output, 'erspan remote 172.16.1.100 local any')
self.assertRegex(output, '102')
test-network: add more tests for SerializeTunneledPackets=, Key=, and friends
2019-03-31 08:44:42 +02:00
self.assertRegex(output, 'ikey 0.0.0.102')
self.assertRegex(output, 'okey 0.0.0.102')
self.assertRegex(output, 'iseq')
self.assertRegex(output, 'oseq')
networkd: Add support for ERSPAN tunnel Please see: https://patchwork.ozlabs.org/patch/800327/ ``` [NetDev] Name=erspan-test Kind=erspan [Tunnel] Independent=true ERSPANIndex=123 Local = 172.16.1.200 Remote = 172.16.1.100 Key=101 SerializeTunneledPackets=true ```
2018-11-26 12:50:09 +01:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_tunnel_independent(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-ipip-tunnel-independent.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd(0)
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['ipiptun99:carrier'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
@expectedFailureIfModuleIsNotAvailable('fou')
def test_fou(self):
# The following redundant check is necessary for CentOS CI.
# Maybe, error handling in lookup_id() in sd-netlink/generic-netlink.c needs to be updated.
self.assertTrue(is_module_available('fou'))
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-fou-ipproto-ipip.netdev', '25-fou-ipproto-gre.netdev',
'25-fou-ipip.netdev', '25-fou-sit.netdev',
'25-fou-gre.netdev', '25-fou-gretap.netdev')
start_networkd(0)
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['ipiptun96:off', 'sittun96:off', 'gretun96:off', 'gretap96:off'])
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip fou show')
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
print(output)
self.assertRegex(output, 'port 55555 ipproto 4')
self.assertRegex(output, 'port 55556 ipproto 47')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show ipiptun96')
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
print(output)
self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show sittun96')
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
print(output)
self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretun96')
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
print(output)
self.assertRegex(output, 'encap fou encap-sport 1001 encap-dport 55556')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show gretap96')
test-network: add tests for FooOverUDP tunnels
2019-03-31 15:04:00 +02:00
print(output)
self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55556')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_vxlan(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-vxlan.netdev', 'vxlan.network',
'11-dummy.netdev', 'vxlan-test1.network')
start_networkd(0)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:degraded', 'vxlan99:degraded'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show vxlan99')
test-network: show command outputs
2018-12-06 15:12:28 +01:00
print(output)
test-network: add tests for BridgeFDB.Destination=
2019-05-03 06:08:55 +02:00
self.assertRegex(output, '999')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
self.assertRegex(output, '5555')
self.assertRegex(output, 'l2miss')
self.assertRegex(output, 'l3miss')
self.assertRegex(output, 'udpcsum')
self.assertRegex(output, 'udp6zerocsumtx')
self.assertRegex(output, 'udp6zerocsumrx')
self.assertRegex(output, 'remcsumtx')
self.assertRegex(output, 'remcsumrx')
self.assertRegex(output, 'gbp')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('bridge fdb show dev vxlan99')
test-network: add tests for BridgeFDB.Destination=
2019-05-03 06:08:55 +02:00
print(output)
self.assertRegex(output, '00:11:22:33:44:55 dst 10.0.0.5 self permanent')
self.assertRegex(output, '00:11:22:33:44:66 dst 10.0.0.6 self permanent')
self.assertRegex(output, '00:11:22:33:44:77 dst 10.0.0.7 self permanent')
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
def test_macsec(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-macsec.netdev', '25-macsec.network', '25-macsec.key',
'macsec.network', '12-dummy.netdev')
start_networkd(0)
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['dummy98:degraded', 'macsec99:routable'])
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show macsec99')
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
print(output)
self.assertRegex(output, 'macsec99@dummy98')
self.assertRegex(output, 'macsec sci [0-9a-f]*000b')
self.assertRegex(output, 'encrypt on')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip macsec show macsec99')
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
print(output)
self.assertRegex(output, 'encrypt on')
self.assertRegex(output, 'TXSC: [0-9a-f]*000b on SA 1')
self.assertRegex(output, '0: PN [0-9]*, state on, key 01000000000000000000000000000000')
self.assertRegex(output, '1: PN [0-9]*, state on, key 02030000000000000000000000000000')
self.assertRegex(output, 'RXSC: c619528fe6a00100, state on')
self.assertRegex(output, '0: PN [0-9]*, state on, key 02030405000000000000000000000000')
self.assertRegex(output, '1: PN [0-9]*, state on, key 02030405060000000000000000000000')
self.assertRegex(output, '2: PN [0-9]*, state off, key 02030405060700000000000000000000')
self.assertRegex(output, '3: PN [0-9]*, state off, key 02030405060708000000000000000000')
self.assertNotRegex(output, 'key 02030405067080900000000000000000')
self.assertRegex(output, 'RXSC: 8c16456c83a90002, state on')
self.assertRegex(output, '0: PN [0-9]*, state off, key 02030400000000000000000000000000')
test-network: add a basic test for nlmon
2019-05-23 04:37:53 +02:00
def test_nlmon(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-nlmon.netdev', 'netdev-link-local-addressing-yes.network')
start_networkd()
test-network: add a basic test for nlmon
2019-05-23 04:37:53 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['nlmon99:carrier'])
test-network: add tests for MACsec
2019-04-05 08:58:50 +02:00
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
class NetworkdL2TPTests(unittest.TestCase, Utilities):
links =[
'l2tp-ses1',
'l2tp-ses2',
'l2tp-ses3',
'l2tp-ses4',
'test1']
units = [
'11-dummy.netdev',
'25-l2tp-dummy.network',
'25-l2tp-ip.netdev',
'25-l2tp-udp.netdev']
l2tp_tunnel_ids = [ '10' ]
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
l2tp_tunnel_remove(self.l2tp_tunnel_ids)
remove_links(self.links)
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
l2tp_tunnel_remove(self.l2tp_tunnel_ids)
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
@expectedFailureIfModuleIsNotAvailable('l2tp_eth')
def test_l2tp_udp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '25-l2tp-dummy.network', '25-l2tp-udp.netdev')
start_networkd(0)
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:routable', 'l2tp-ses1:off', 'l2tp-ses2:off'])
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip l2tp show tunnel tunnel_id 10')
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
print(output)
self.assertRegex(output, "Tunnel 10, encap UDP")
self.assertRegex(output, "From 192.168.30.100 to 192.168.30.101")
self.assertRegex(output, "Peer tunnel 11")
self.assertRegex(output, "UDP source / dest ports: 3000/4000")
self.assertRegex(output, "UDP checksum: enabled")
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip l2tp show session tid 10 session_id 15')
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
print(output)
self.assertRegex(output, "Session 15 in tunnel 10")
self.assertRegex(output, "Peer session 16, tunnel 11")
self.assertRegex(output, "interface name: l2tp-ses1")
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip l2tp show session tid 10 session_id 17')
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
print(output)
self.assertRegex(output, "Session 17 in tunnel 10")
self.assertRegex(output, "Peer session 18, tunnel 11")
self.assertRegex(output, "interface name: l2tp-ses2")
@expectedFailureIfModuleIsNotAvailable('l2tp_ip')
def test_l2tp_ip(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '25-l2tp-dummy.network', '25-l2tp-ip.netdev')
start_networkd(0)
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['test1:routable', 'l2tp-ses3:off', 'l2tp-ses4:off'])
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip l2tp show tunnel tunnel_id 10')
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
print(output)
self.assertRegex(output, "Tunnel 10, encap IP")
self.assertRegex(output, "From 192.168.30.100 to 192.168.30.101")
self.assertRegex(output, "Peer tunnel 12")
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip l2tp show session tid 10 session_id 25')
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
print(output)
self.assertRegex(output, "Session 25 in tunnel 10")
self.assertRegex(output, "Peer session 26, tunnel 12")
self.assertRegex(output, "interface name: l2tp-ses3")
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip l2tp show session tid 10 session_id 27')
test-network: add tests for L2TP
2019-03-12 09:11:24 +01:00
print(output)
self.assertRegex(output, "Session 27 in tunnel 10")
self.assertRegex(output, "Peer session 28, tunnel 12")
self.assertRegex(output, "interface name: l2tp-ses4")
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdNetworkTests(unittest.TestCase, Utilities):
test-network: sort links and units
2018-12-06 14:57:20 +01:00
links = [
'bond199',
'dummy98',
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
'dummy99',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'test1']
units = [
'11-dummy.netdev',
'12-dummy.netdev',
'23-active-slave.network',
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
'24-keep-configuration-static.network',
test-network: move test_domain() to NetworkdNetworkTests class
2019-05-24 08:34:19 +02:00
'24-search-domain.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-address-link-section.network',
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
'25-address-preferred-lifetime-zero-ipv6.network',
'25-address-static.network',
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
'25-bind-carrier.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-bond-active-backup-slave.netdev',
'25-fibrule-invert.network',
'25-fibrule-port-range.network',
'25-ipv6-address-label-section.network',
networkd: Static neighbor support When using networkd we currently have no way of ensuring that static neighbor entries are set when our link comes up. This change adds a new section to the network definition that allows multiple static neighbors to be set on a link.
2018-11-29 04:00:58 +01:00
'25-neighbor-section.network',
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
'25-link-local-addressing-no.network',
'25-link-local-addressing-yes.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-link-section-unmanaged.network',
tests: Add test for IPv6 source routing The test is a bit messy because it must be done on a device that enforces a tentative state for IPv6 addresses, and it appears that the dummy device does not. So we use a bond instead. Signed-off-by: Daniel Axtens <dja@axtens.net>
2019-01-14 15:15:15 +01:00
'25-route-ipv6-src.network',
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
'25-route-static.network',
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
'25-sysctl-disable-ipv6.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'25-sysctl.network',
'configure-without-carrier.network',
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
'routing-policy-rule-dummy98.network',
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
'routing-policy-rule-test1.network']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: use setUp() and tearDown() to delete routing policy rule tables
2019-05-24 06:44:49 +02:00
routing_policy_rule_tables = ['7', '8']
test-network: remove routes even on failure
2019-05-24 06:49:51 +02:00
routes = [['blackhole', '202.54.1.2'], ['unreachable', '202.54.1.3'], ['prohibit', '202.54.1.4']]
test-network: use setUp() and tearDown() to delete routing policy rule tables
2019-05-24 06:44:49 +02:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_routing_policy_rule_tables(self.routing_policy_rule_tables)
remove_routes(self.routes)
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_routing_policy_rule_tables(self.routing_policy_rule_tables)
remove_routes(self.routes)
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
def test_address_static(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-address-static.network', '12-dummy.netdev')
start_networkd(0)
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['dummy98:routable'])
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev dummy98')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
print(output)
self.assertRegex(output, 'inet 10.1.2.3/16 brd 10.1.255.255 scope global dummy98')
self.assertRegex(output, 'inet 10.1.2.4/16 brd 10.1.255.255 scope global secondary dummy98')
self.assertRegex(output, 'inet 10.2.2.4/16 brd 10.2.255.255 scope global dummy98')
# invalid sections
self.assertNotRegex(output, '10.10.0.1/16')
self.assertNotRegex(output, '10.10.0.2/16')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev dummy98 label 32')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
self.assertRegex(output, 'inet 10.3.2.3/16 brd 10.3.255.255 scope global 32')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev dummy98 label 33')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
self.assertRegex(output, 'inet 10.4.2.3 peer 10.4.2.4/16 scope global 33')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev dummy98 label 34')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
self.assertRegex(output, 'inet 192.168.[0-9]*.1/24 brd 192.168.[0-9]*.255 scope global 34')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev dummy98 label 35')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
self.assertRegex(output, 'inet 172.[0-9]*.0.1/16 brd 172.[0-9]*.255.255 scope global 35')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev dummy98')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
print(output)
self.assertRegex(output, 'inet6 2001:db8:0:f101::15/64 scope global')
self.assertRegex(output, 'inet6 2001:db8:0:f101::16/64 scope global')
self.assertRegex(output, 'inet6 2001:db8:0:f102::15/64 scope global')
self.assertRegex(output, 'inet6 2001:db8:0:f102::16/64 scope global')
self.assertRegex(output, 'inet6 2001:db8:0:f103::20 peer 2001:db8:0:f103::10/128 scope global')
self.assertRegex(output, 'inet6 fd[0-9a-f:]*1/64 scope global')
def test_address_preferred_lifetime_zero_ipv6(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-address-preferred-lifetime-zero-ipv6.network', '12-dummy.netdev')
test-network: explicitly set sleep time
2019-06-14 09:47:06 +02:00
start_networkd(5)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('dummy98', 'routable', setup_state='configuring')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dummy98')
test-network: merge tests about static addresses And use wait_online()
2019-03-21 21:08:20 +01:00
print(output)
self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope link deprecated dummy98')
self.assertRegex(output, 'inet6 2001:db8:0:f101::1/64 scope global')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_configure_without_carrier(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('configure-without-carrier.network', '11-dummy.netdev')
start_networkd()
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'test1')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '192.168.0.15')
self.assertRegex(output, '192.168.0.1')
self.assertRegex(output, 'routable')
def test_routing_policy_rule(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('routing-policy-rule-test1.network', '11-dummy.netdev')
test-network: drop relevant ip routing policy rules before testing
2019-02-27 11:22:27 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd()
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip rule')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '111')
self.assertRegex(output, 'from 192.168.100.18')
tests: make NetworkdNetWorkTests.test_routing_policy_rule pass on CentOS Depending on the content of /etc/iproute2/rt_dsfield, ip can print either `0x08` or `throughput` as was shown in https://github.com/systemd/systemd/issues/10617#issuecomment-435200859.
2018-11-02 17:03:45 +01:00
self.assertRegex(output, r'tos (?:0x08|throughput)\s')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
self.assertRegex(output, 'iif test1')
self.assertRegex(output, 'oif test1')
self.assertRegex(output, 'lookup 7')
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
def test_routing_policy_rule_issue_11280(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('routing-policy-rule-test1.network', '11-dummy.netdev',
'routing-policy-rule-dummy98.network', '12-dummy.netdev')
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
for trial in range(3):
# Remove state files only first time
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(remove_state_files=(trial == 0))
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
self.check_link_exists('dummy98')
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip rule list table 7')
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
print(output)
self.assertRegex(output, '111: from 192.168.100.18 tos (?:0x08|throughput) iif test1 oif test1 lookup 7')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip rule list table 8')
test-network: add testcase for issue #11280
2019-02-22 04:28:51 +01:00
print(output)
self.assertRegex(output, '112: from 192.168.101.18 tos (?:0x08|throughput) iif dummy98 oif dummy98 lookup 8')
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
@expectedFailureIfRoutingPolicyPortRangeIsNotAvailable()
networkd: add support to configure ip rule port range and protocol. Please see: iprule: support for ip_proto, sport and dport match options https://git.kernel.org/pub/scm/network/iproute2/iproute2.git/commit/?id=f686f764682745daf6a93b0a6330ba42a961f858 Closes 10622
2018-11-27 06:28:54 +01:00
def test_routing_policy_rule_port_range(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-fibrule-port-range.network', '11-dummy.netdev')
test-network: drop relevant ip routing policy rules before testing
2019-02-27 11:22:27 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd()
networkd: add support to configure ip rule port range and protocol. Please see: iprule: support for ip_proto, sport and dport match options https://git.kernel.org/pub/scm/network/iproute2/iproute2.git/commit/?id=f686f764682745daf6a93b0a6330ba42a961f858 Closes 10622
2018-11-27 06:28:54 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip rule')
networkd: add support to configure ip rule port range and protocol. Please see: iprule: support for ip_proto, sport and dport match options https://git.kernel.org/pub/scm/network/iproute2/iproute2.git/commit/?id=f686f764682745daf6a93b0a6330ba42a961f858 Closes 10622
2018-11-27 06:28:54 +01:00
print(output)
self.assertRegex(output, '111')
self.assertRegex(output, 'from 192.168.100.18')
self.assertRegex(output, '1123-1150')
self.assertRegex(output, '3224-3290')
self.assertRegex(output, 'tcp')
self.assertRegex(output, 'lookup 7')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: check port range and ipproto attributes are supported by kernel and ip command
2019-02-06 09:27:28 +01:00
@expectedFailureIfRoutingPolicyIPProtoIsNotAvailable()
test-network: Add test for invert RPDB rule
2018-12-06 06:30:36 +01:00
def test_routing_policy_rule_invert(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-fibrule-invert.network', '11-dummy.netdev')
test-network: drop relevant ip routing policy rules before testing
2019-02-27 11:22:27 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd()
test-network: Add test for invert RPDB rule
2018-12-06 06:30:36 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip rule')
test-network: Add test for invert RPDB rule
2018-12-06 06:30:36 +01:00
print(output)
self.assertRegex(output, '111')
self.assertRegex(output, 'not.*?from.*?192.168.100.18')
self.assertRegex(output, 'tcp')
self.assertRegex(output, 'lookup 7')
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
def test_route_static(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-route-static.network', '12-dummy.netdev')
start_networkd(0)
fix: systemd-networkd reverse route ordering We missing a default route. Add gateway first. This fixes https://github.com/systemd/systemd/issues/5430
2018-11-26 18:13:17 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['dummy98:routable'])
fix: systemd-networkd reverse route ordering We missing a default route. Add gateway first. This fixes https://github.com/systemd/systemd/issues/5430
2018-11-26 18:13:17 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 route show dev dummy98')
fix: systemd-networkd reverse route ordering We missing a default route. Add gateway first. This fixes https://github.com/systemd/systemd/issues/5430
2018-11-26 18:13:17 +01:00
print(output)
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, '2001:1234:5:8fff:ff:ff:ff:ff proto static')
self.assertRegex(output, '2001:1234:5:8f63::1 proto kernel')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 route show dev dummy98 default')
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, 'default via 2001:1234:5:8fff:ff:ff:ff:ff proto static metric 1024 pref medium')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 route show dev dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, '149.10.124.48/28 proto kernel scope link src 149.10.124.58')
self.assertRegex(output, '149.10.124.64 proto static scope link')
test-network: add a test for IPv4LLRoute=
2019-05-15 05:43:36 +02:00
self.assertRegex(output, '169.254.0.0/16 proto static scope link metric 2048')
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, '192.168.1.1 proto static initcwnd 20')
self.assertRegex(output, '192.168.1.2 proto static initrwnd 30')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 route show dev dummy98 default')
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, 'default via 149.10.125.65 proto static onlink')
self.assertRegex(output, 'default via 149.10.124.64 proto static')
test-network: add tests for DefaultRouteOnDevice=
2019-05-07 06:18:30 +02:00
self.assertRegex(output, 'default proto static')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show type blackhole')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, 'blackhole 202.54.1.2 proto static')
test-network: add tests for #5430 and GatewayOnLink=
2018-11-26 07:46:55 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show type unreachable')
test-network: add tests for #5430 and GatewayOnLink=
2018-11-26 07:46:55 +01:00
print(output)
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, 'unreachable 202.54.1.3 proto static')
test-network: add tests for #5430 and GatewayOnLink=
2018-11-26 07:46:55 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show type prohibit')
test-network: add tests for #5430 and GatewayOnLink=
2018-11-26 07:46:55 +01:00
print(output)
test-network: merge tests for [Route] section
2019-03-27 21:53:45 +01:00
self.assertRegex(output, 'prohibit 202.54.1.4 proto static')
test-network: add tests for #5430 and GatewayOnLink=
2018-11-26 07:46:55 +01:00
tests: Add test for IPv6 source routing The test is a bit messy because it must be done on a device that enforces a tentative state for IPv6 addresses, and it appears that the dummy device does not. So we use a bond instead. Signed-off-by: Daniel Axtens <dja@axtens.net>
2019-01-14 15:15:15 +01:00
def test_ip_route_ipv6_src_route(self):
# a dummy device does not make the addresses go through tentative state, so we
# reuse a bond from an earlier test, which does make the addresses go through
# tentative state, and do our test on that
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('23-active-slave.network', '25-route-ipv6-src.network', '25-bond-active-backup-slave.netdev', '12-dummy.netdev')
start_networkd()
tests: Add test for IPv6 source routing The test is a bit messy because it must be done on a device that enforces a tentative state for IPv6 addresses, and it appears that the dummy device does not. So we use a bond instead. Signed-off-by: Daniel Axtens <dja@axtens.net>
2019-01-14 15:15:15 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
self.check_link_exists('bond199')
tests: Add test for IPv6 source routing The test is a bit messy because it must be done on a device that enforces a tentative state for IPv6 addresses, and it appears that the dummy device does not. So we use a bond instead. Signed-off-by: Daniel Axtens <dja@axtens.net>
2019-01-14 15:15:15 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 route list dev bond199')
tests: Add test for IPv6 source routing The test is a bit messy because it must be done on a device that enforces a tentative state for IPv6 addresses, and it appears that the dummy device does not. So we use a bond instead. Signed-off-by: Daniel Axtens <dja@axtens.net>
2019-01-14 15:15:15 +01:00
print(output)
self.assertRegex(output, 'abcd::/16')
self.assertRegex(output, 'src')
self.assertRegex(output, '2001:1234:56:8f63::2')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_ip_link_mac_address(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-address-link-section.network', '12-dummy.netdev')
start_networkd()
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip link show dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '00:01:02:aa:bb:cc')
def test_ip_link_unmanaged(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-link-section-unmanaged.network', '12-dummy.netdev')
start_networkd()
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'unmanaged')
def test_ipv6_address_label(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-ipv6-address-label-section.network', '12-dummy.netdev')
start_networkd()
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip addrlabel list')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '2004:da8:1::/64')
networkd: Static neighbor support When using networkd we currently have no way of ensuring that static neighbor entries are set when our link comes up. This change adds a new section to the network definition that allows multiple static neighbors to be set on a link.
2018-11-29 04:00:58 +01:00
def test_ipv6_neighbor(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-neighbor-section.network', '12-dummy.netdev')
start_networkd()
networkd: Static neighbor support When using networkd we currently have no way of ensuring that static neighbor entries are set when our link comes up. This change adds a new section to the network definition that allows multiple static neighbors to be set on a link.
2018-11-29 04:00:58 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
networkd: Static neighbor support When using networkd we currently have no way of ensuring that static neighbor entries are set when our link comes up. This change adds a new section to the network definition that allows multiple static neighbors to be set on a link.
2018-11-29 04:00:58 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip neigh list')
networkd: Static neighbor support When using networkd we currently have no way of ensuring that static neighbor entries are set when our link comes up. This change adds a new section to the network definition that allows multiple static neighbors to be set on a link.
2018-11-29 04:00:58 +01:00
print(output)
self.assertRegex(output, '192.168.10.1.*00:00:5e:00:02:65.*PERMANENT')
test: fix neighbor address
2018-12-26 23:16:20 +01:00
self.assertRegex(output, '2004:da8:1::1.*00:00:5e:00:02:66.*PERMANENT')
networkd: Static neighbor support When using networkd we currently have no way of ensuring that static neighbor entries are set when our link comes up. This change adds a new section to the network definition that allows multiple static neighbors to be set on a link.
2018-11-29 04:00:58 +01:00
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
def test_link_local_addressing(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-link-local-addressing-yes.network', '11-dummy.netdev',
'25-link-local-addressing-no.network', '12-dummy.netdev')
start_networkd(0)
wait_online(['test1:degraded', 'dummy98:carrier'])
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
self.check_link_exists('dummy98')
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev test1')
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
print(output)
self.assertRegex(output, 'inet .* scope link')
self.assertRegex(output, 'inet6 .* scope link')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev dummy98')
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
print(output)
self.assertNotRegex(output, 'inet6* .* scope link')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'degraded')
self.check_operstate('dummy98', 'carrier')
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
'''
Documentation/networking/ip-sysctl.txt
addr_gen_mode - INTEGER
Defines how link-local and autoconf addresses are generated.
0: generate address based on EUI64 (default)
1: do no generate a link-local address, use EUI64 for addresses generated
from autoconf
2: generate stable privacy addresses, using the secret from
stable_secret (RFC7217)
3: generate stable privacy addresses, using a random secret if unset
'''
test1_addr_gen_mode = ''
if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'stable_secret')):
with open(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'stable_secret')) as f:
try:
f.readline()
except IOError:
# if stable_secret is unset, then EIO is returned
test1_addr_gen_mode = '0'
else:
test1_addr_gen_mode = '2'
else:
test1_addr_gen_mode = '0'
if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'addr_gen_mode')):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertEqual(read_ipv6_sysctl_attr('test1', 'addr_gen_mode'), test1_addr_gen_mode)
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'dummy98'), 'addr_gen_mode')):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'addr_gen_mode'), '1')
test-network: add tests for LinkLocalAddressing=
2019-02-12 02:28:49 +01:00
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_sysctl(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-sysctl.network', '12-dummy.netdev')
start_networkd(0)
wait_online(['dummy98:degraded'])
self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'forwarding'), '1')
self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'use_tempaddr'), '2')
self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'dad_transmits'), '3')
self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'hop_limit'), '5')
self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'proxy_ndp'), '1')
self.assertEqual(read_ipv4_sysctl_attr('dummy98', 'forwarding'),'1')
self.assertEqual(read_ipv4_sysctl_attr('dummy98', 'proxy_arp'), '1')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
def test_sysctl_disable_ipv6(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-sysctl-disable-ipv6.network', '12-dummy.netdev')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
print('## Disable ipv6')
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('sysctl net.ipv6.conf.all.disable_ipv6=1')
check_output('sysctl net.ipv6.conf.default.disable_ipv6=1')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['dummy98:routable'])
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dummy98')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
print(output)
self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope global dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dummy98')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
print(output)
self.assertEqual(output, '')
test-network: add more test cases when ipv6 is disabled
2019-06-12 04:01:32 +02:00
output = check_output('ip -4 route show dev dummy98')
print(output)
self.assertEqual(output, '10.2.0.0/16 proto kernel scope link src 10.2.3.4')
output = check_output('ip -6 route show dev dummy98')
print(output)
self.assertEqual(output, '')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link del dummy98')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
print('## Enable ipv6')
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('sysctl net.ipv6.conf.all.disable_ipv6=0')
check_output('sysctl net.ipv6.conf.default.disable_ipv6=0')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['dummy98:routable'])
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dummy98')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
print(output)
self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope global dummy98')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dummy98')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
print(output)
test-network: add more test cases when ipv6 is disabled
2019-06-12 04:01:32 +02:00
self.assertRegex(output, 'inet6 2607:5300:203:3906::/64 scope global')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
self.assertRegex(output, 'inet6 .* scope link')
test-network: add more test cases when ipv6 is disabled
2019-06-12 04:01:32 +02:00
output = check_output('ip -4 route show dev dummy98')
print(output)
self.assertEqual(output, '10.2.0.0/16 proto kernel scope link src 10.2.3.4')
output = check_output('ip -6 route show dev dummy98')
print(output)
self.assertRegex(output, 'default via 2607:5300:203:39ff:ff:ff:ff:ff proto static')
test-network: add testcases for handling disable_ipv6 sysctl property
2019-02-18 07:26:26 +01:00
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
def test_bind_carrier(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-bind-carrier.network', '11-dummy.netdev')
start_networkd()
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy98 type dummy')
check_output('ip link set dummy98 up')
test-network: decrease sleep time in test_bind_carrier() This effectively reverts 63eb09569aa90721be4accbea4b78421f3c1ba7c, as the commit does not fix #11724.
2019-02-16 19:59:15 +01:00
time.sleep(2)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show test1')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
print(output)
self.assertRegex(output, 'UP,LOWER_UP')
self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'routable')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy99 type dummy')
check_output('ip link set dummy99 up')
test-network: decrease sleep time in test_bind_carrier() This effectively reverts 63eb09569aa90721be4accbea4b78421f3c1ba7c, as the commit does not fix #11724.
2019-02-16 19:59:15 +01:00
time.sleep(2)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show test1')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
print(output)
self.assertRegex(output, 'UP,LOWER_UP')
self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'routable')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link del dummy98')
test-network: decrease sleep time in test_bind_carrier() This effectively reverts 63eb09569aa90721be4accbea4b78421f3c1ba7c, as the commit does not fix #11724.
2019-02-16 19:59:15 +01:00
time.sleep(2)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show test1')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
print(output)
self.assertRegex(output, 'UP,LOWER_UP')
self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'routable')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link del dummy99')
test-network: decrease sleep time in test_bind_carrier() This effectively reverts 63eb09569aa90721be4accbea4b78421f3c1ba7c, as the commit does not fix #11724.
2019-02-16 19:59:15 +01:00
time.sleep(2)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show test1')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
print(output)
self.assertNotRegex(output, 'UP,LOWER_UP')
self.assertRegex(output, 'DOWN')
self.assertNotRegex(output, '192.168.10')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'off')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy98 type dummy')
check_output('ip link set dummy98 up')
test-network: decrease sleep time in test_bind_carrier() This effectively reverts 63eb09569aa90721be4accbea4b78421f3c1ba7c, as the commit does not fix #11724.
2019-02-16 19:59:15 +01:00
time.sleep(2)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show test1')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
print(output)
self.assertRegex(output, 'UP,LOWER_UP')
self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'routable')
test-network: add test for BindCarrier=
2019-02-07 06:22:23 +01:00
test-network: move test_domain() to NetworkdNetworkTests class
2019-05-24 08:34:19 +02:00
def test_domain(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('12-dummy.netdev', '24-search-domain.network')
start_networkd(0)
wait_online(['dummy98:routable'])
test-network: move test_domain() to NetworkdNetworkTests class
2019-05-24 08:34:19 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'dummy98', env=env)
test-network: move test_domain() to NetworkdNetworkTests class
2019-05-24 08:34:19 +02:00
print(output)
self.assertRegex(output, 'Address: 192.168.42.100')
self.assertRegex(output, 'DNS: 192.168.42.1')
self.assertRegex(output, 'Search Domains: one')
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
def test_keep_configuration_static(self):
check_output('systemctl stop systemd-networkd')
check_output('ip link add name dummy98 type dummy')
check_output('ip address add 10.1.2.3/16 dev dummy98')
check_output('ip address add 10.2.3.4/16 dev dummy98 valid_lft 600 preferred_lft 500')
output = check_output('ip address show dummy98')
print(output)
self.assertRegex(output, 'inet 10.1.2.3/16 scope global dummy98')
self.assertRegex(output, 'inet 10.2.3.4/16 scope global dynamic dummy98')
output = check_output('ip route show dev dummy98')
print(output)
copy_unit_to_networkd_unit_path('24-keep-configuration-static.network')
start_networkd(0)
wait_online(['dummy98:routable'])
output = check_output('ip address show dummy98')
print(output)
self.assertRegex(output, 'inet 10.1.2.3/16 scope global dummy98')
self.assertNotRegex(output, 'inet 10.2.3.4/16 scope global dynamic dummy98')
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdBondTests(unittest.TestCase, Utilities):
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
links = [
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
'bond199',
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
'bond99',
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
'dummy98',
'test1']
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
units = [
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
'11-dummy.netdev',
'12-dummy.netdev',
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
'23-active-slave.network',
'23-bond199.network',
'23-primary-slave.network',
'23-test1-bond199.network',
'25-bond-active-backup-slave.netdev',
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
'25-bond.netdev',
'bond99.network',
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
'bond-slave.network']
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
def test_bond_active_slave(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('23-active-slave.network', '23-bond199.network', '25-bond-active-backup-slave.netdev', '12-dummy.netdev')
start_networkd()
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
self.check_link_exists('bond199')
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show bond199')
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
print(output)
self.assertRegex(output, 'active_slave dummy98')
def test_bond_primary_slave(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('23-primary-slave.network', '23-test1-bond199.network', '25-bond-active-backup-slave.netdev', '11-dummy.netdev')
start_networkd()
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('test1')
self.check_link_exists('bond199')
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show bond199')
test-network: move tests related to bonding
2019-03-21 21:20:04 +01:00
print(output)
self.assertRegex(output, 'primary test1')
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
def test_bond_operstate(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-bond.netdev', '11-dummy.netdev', '12-dummy.netdev',
'bond99.network','bond-slave.network')
start_networkd()
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('bond99')
self.check_link_exists('dummy98')
self.check_link_exists('test1')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show dummy98')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
print(output)
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
self.assertRegex(output, 'SLAVE,UP,LOWER_UP')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show test1')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
print(output)
self.assertRegex(output, 'SLAVE,UP,LOWER_UP')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show bond99')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
print(output)
self.assertRegex(output, 'MASTER,UP,LOWER_UP')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('dummy98', 'enslaved')
self.check_operstate('test1', 'enslaved')
self.check_operstate('bond99', 'routable')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link set dummy98 down')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
time.sleep(2)
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('dummy98', 'off')
self.check_operstate('test1', 'enslaved')
self.check_operstate('bond99', 'degraded-carrier')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link set dummy98 up')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
time.sleep(2)
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('dummy98', 'enslaved')
self.check_operstate('test1', 'enslaved')
self.check_operstate('bond99', 'routable')
test-network: add tests for bonding
2019-02-09 14:56:42 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link set dummy98 down')
check_output('ip link set test1 down')
test-network: wait for bond interface to be no-carrier operational state
2019-05-15 11:46:41 +02:00
time.sleep(2)
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('dummy98', 'off')
self.check_operstate('test1', 'off')
test-network: wait for bond interface to be no-carrier operational state
2019-05-15 11:46:41 +02:00
for trial in range(30):
if trial > 0:
time.sleep(1)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show bond99')
test-network: wait for bond interface to be no-carrier operational state
2019-05-15 11:46:41 +02:00
print(output)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
if get_operstate('bond99') == 'no-carrier':
test-network: wait for bond interface to be no-carrier operational state
2019-05-15 11:46:41 +02:00
break
else:
# Huh? Kernel does not recognize that all slave interfaces are down?
# Let's confirm that networkd's operstate is consistent with ip's result.
self.assertNotRegex(output, 'NO-CARRIER')
test-network: testing with two bond slaves
2019-02-20 07:04:15 +01:00
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdBridgeTests(unittest.TestCase, Utilities):
test-network: sort links and units
2018-12-06 14:57:20 +01:00
links = [
'bridge99',
'dummy98',
'test1']
units = [
'11-dummy.netdev',
'12-dummy.netdev',
'26-bridge.netdev',
'26-bridge-slave-interface-1.network',
'26-bridge-slave-interface-2.network',
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
'bridge99-ignore-carrier-loss.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'bridge99.network']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_bridge_property(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '12-dummy.netdev', '26-bridge.netdev',
'26-bridge-slave-interface-1.network', '26-bridge-slave-interface-2.network',
'bridge99.network')
start_networkd()
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
self.check_link_exists('test1')
self.check_link_exists('bridge99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show test1')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'master')
self.assertRegex(output, 'bridge')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'master')
self.assertRegex(output, 'bridge')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip addr show bridge99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
self.assertRegex(output, '192.168.0.15/24')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('bridge -d link show dummy98')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'hairpin_mode'), '1')
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'path_cost'), '400')
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'unicast_flood'), '1')
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'multicast_flood'), '0')
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'multicast_fast_leave'), '1')
networkd: Add bridge port capabilities This PR adds the configuration switches for multicast flooding, neighbor suppression and learning of a bridge port.
2019-03-10 21:25:24 +01:00
if (os.path.exists('/sys/devices/virtual/net/bridge99/lower_dummy98/brport/neigh_suppress')):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'neigh_suppress'), '1')
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'learning'), '0')
test-network: add test for bridge MulticastToUnicast
2018-12-06 07:24:14 +01:00
# CONFIG_BRIDGE_IGMP_SNOOPING=y
if (os.path.exists('/sys/devices/virtual/net/bridge00/lower_dummy98/brport/multicast_to_unicast')):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'multicast_to_unicast'), '1')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('test1', 'enslaved')
self.check_operstate('dummy98', 'enslaved')
self.check_operstate('bridge99', 'routable')
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('ip address add 192.168.0.16/24 dev bridge99')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
time.sleep(1)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip addr show bridge99')
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
print(output)
self.assertRegex(output, '192.168.0.16/24')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('bridge99', 'routable')
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
self.assertEqual(call('ip link del test1'), 0)
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
time.sleep(3)
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('bridge99', 'degraded-carrier')
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link del dummy98')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
time.sleep(3)
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('bridge99', 'no-carrier')
test-network: add more tests for Bridge=
2019-02-20 03:33:00 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show bridge99')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
print(output)
self.assertRegex(output, 'NO-CARRIER')
self.assertNotRegex(output, '192.168.0.15/24')
self.assertNotRegex(output, '192.168.0.16/24')
def test_bridge_ignore_carrier_loss(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('11-dummy.netdev', '12-dummy.netdev', '26-bridge.netdev',
'26-bridge-slave-interface-1.network', '26-bridge-slave-interface-2.network',
'bridge99-ignore-carrier-loss.network')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip rule del table 100')
test-network: drop relevant ip routing policy rules before testing
2019-02-27 11:22:27 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd()
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('dummy98')
self.check_link_exists('test1')
self.check_link_exists('bridge99')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('ip address add 192.168.0.16/24 dev bridge99')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
time.sleep(1)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
check_output('ip link del test1')
check_output('ip link del dummy98')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
time.sleep(3)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show bridge99')
test-network: add testcases for IgnoreCarrierLoss=
2019-02-06 12:45:56 +01:00
print(output)
self.assertRegex(output, 'NO-CARRIER')
self.assertRegex(output, 'inet 192.168.0.15/24 brd 192.168.0.255 scope global bridge99')
self.assertRegex(output, 'inet 192.168.0.16/24 scope global secondary bridge99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip rule del table 100')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
def test_bridge_ignore_carrier_loss_frequent_loss_and_gain(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('26-bridge.netdev', '26-bridge-slave-interface-1.network',
'bridge99-ignore-carrier-loss.network')
test-network: drop relevant ip routing policy rules before testing
2019-02-27 11:22:27 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip rule del table 100')
test-network: drop relevant ip routing policy rules before testing
2019-02-27 11:22:27 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd()
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
test-network: introduce check_link_exists()
2019-05-20 03:05:50 +02:00
self.check_link_exists('bridge99')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy98 type dummy')
check_output('ip link set dummy98 up')
check_output('ip link del dummy98')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy98 type dummy')
check_output('ip link set dummy98 up')
check_output('ip link del dummy98')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy98 type dummy')
check_output('ip link set dummy98 up')
check_output('ip link del dummy98')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
networkd-tests.py: use check_output() instead of unittests' assertEqual() It's pretty much the same thing, but more in pytest style, without the unittest boilerplate.
2019-06-05 12:03:01 +02:00
check_output('ip link add dummy98 type dummy')
check_output('ip link set dummy98 up')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
test-network: wait for bridge slave to be enslaved in test_bridge_ignore_carrier_loss_frequent_loss_and_gain()
2019-05-20 15:40:54 +02:00
for trial in range(30):
if trial > 0:
time.sleep(1)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
if get_operstate('bridge99') == 'routable' and get_operstate('dummy98') == 'enslaved':
test-network: wait for bridge slave to be enslaved in test_bridge_ignore_carrier_loss_frequent_loss_and_gain()
2019-05-20 15:40:54 +02:00
break
else:
self.assertTrue(False)
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show bridge99')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
print(output)
self.assertRegex(output, 'inet 192.168.0.15/24 brd 192.168.0.255 scope global bridge99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip rule list table 100')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
print(output)
self.assertEqual(output, '0: from all to 8.8.8.8 lookup 100')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
call('ip rule del table 100')
test-network: add more tests for IgnoreCarrierLoss= Suggested by @amishmm in #9262.
2019-02-20 04:45:40 +01:00
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdLLDPTests(unittest.TestCase, Utilities):
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
links = ['veth99']
test-network: sort links and units
2018-12-06 14:57:20 +01:00
units = [
'23-emit-lldp.network',
'24-lldp.network',
'25-veth.netdev']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_lldp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('23-emit-lldp.network', '24-lldp.network', '25-veth.netdev')
start_networkd(0)
wait_online(['veth99:degraded', 'veth-peer:degraded'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'lldp', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'veth-peer')
self.assertRegex(output, 'veth99')
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdRATests(unittest.TestCase, Utilities):
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
links = ['veth99']
test-network: sort links and units
2018-12-06 14:57:20 +01:00
units = [
'25-veth.netdev',
'ipv6-prefix.network',
'ipv6-prefix-veth.network']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_ipv6_prefix_delegation(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
warn_about_firewalld()
copy_unit_to_networkd_unit_path('25-veth.netdev', 'ipv6-prefix.network', 'ipv6-prefix-veth.network')
start_networkd(0)
wait_online(['veth99:routable', 'veth-peer:degraded'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '2002:da8:1:0')
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdDHCPServerTests(unittest.TestCase, Utilities):
test-network: move test_domain() to NetworkdNetworkTests class
2019-05-24 08:34:19 +02:00
links = ['veth99']
test-network: sort links and units
2018-12-06 14:57:20 +01:00
units = [
'25-veth.netdev',
'dhcp-client.network',
'dhcp-client-timezone-router.network',
'dhcp-server.network',
'dhcp-server-timezone-router.network']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp_server(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
warn_about_firewalld()
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-client.network', 'dhcp-server.network')
start_networkd(0)
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '192.168.5.*')
self.assertRegex(output, 'Gateway: 192.168.5.1')
self.assertRegex(output, 'DNS: 192.168.5.1')
self.assertRegex(output, 'NTP: 192.168.5.1')
def test_emit_router_timezone(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
warn_about_firewalld()
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-client-timezone-router.network', 'dhcp-server-timezone-router.network')
start_networkd(0)
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'Gateway: 192.168.5.*')
self.assertRegex(output, '192.168.5.*')
self.assertRegex(output, 'Europe/Berlin')
test-network: rename needlessly long class names
2019-05-24 08:17:41 +02:00
class NetworkdDHCPClientTests(unittest.TestCase, Utilities):
test-network: sort links and units
2018-12-06 14:57:20 +01:00
links = [
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
'veth99',
'vrf99']
test-network: sort links and units
2018-12-06 14:57:20 +01:00
units = [
'25-veth.netdev',
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
'25-vrf.netdev',
'25-vrf.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'dhcp-client-anonymize.network',
test-network: add testcase for #1850
2019-02-27 11:10:47 +01:00
'dhcp-client-gateway-onlink-implicit.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'dhcp-client-ipv4-dhcp-settings.network',
'dhcp-client-ipv4-only-ipv6-disabled.network',
'dhcp-client-ipv4-only.network',
'dhcp-client-ipv6-only.network',
'dhcp-client-ipv6-rapid-commit.network',
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
'dhcp-client-keep-configuration-dhcp-on-stop.network',
'dhcp-client-keep-configuration-dhcp.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'dhcp-client-listen-port.network',
'dhcp-client-route-metric.network',
'dhcp-client-route-table.network',
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
'dhcp-client-vrf.network',
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
'dhcp-client-with-ipv4ll-fallback-with-dhcp-server.network',
'dhcp-client-with-ipv4ll-fallback-without-dhcp-server.network',
test-network: fix test_dhcp_server() and test_ipv6_prefix_delegation() The tests have been broken since 30d3b54ebad41082e99cabbee815cb113aa0b5c4.
2019-02-03 04:36:36 +01:00
'dhcp-client.network',
test-network: sort links and units
2018-12-06 14:57:20 +01:00
'dhcp-server-veth-peer.network',
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
'dhcp-v4-server-veth-peer.network',
'static.network']
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def setUp(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
stop_dnsmasq(dnsmasq_pid_file)
remove_links(self.links)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def tearDown(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
stop_dnsmasq(dnsmasq_pid_file)
remove_lease_file()
remove_log_file()
remove_links(self.links)
remove_unit_from_networkd_path(self.units)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp_client_ipv6_only(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '2600::')
self.assertNotRegex(output, '192.168.5')
test-network: add a tiny test for IPv6Token=
2019-05-12 00:34:13 +02:00
# Confirm that ipv6 token is not set in the kernel
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip token show dev veth99')
test-network: add a tiny test for IPv6Token=
2019-05-12 00:34:13 +02:00
print(output)
self.assertRegex(output, 'token :: dev veth99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp_client_ipv4_only(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv4-only-ipv6-disabled.network')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertNotRegex(output, '2600::')
self.assertRegex(output, '192.168.5')
def test_dhcp_client_ipv4_ipv6(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network',
'dhcp-client-ipv4-only.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
# link become 'routable' when at least one protocol provide an valid address.
test-network: do not allow addresses in tentative state
2019-06-04 20:55:32 +02:00
self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '2600::')
self.assertRegex(output, '192.168.5')
def test_dhcp_client_settings(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv4-dhcp-settings.network')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add tests for DHCP.RouteTable=
2019-02-11 13:38:54 +01:00
print('## ip address show dev veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '12:34:56:78:9a:bc')
self.assertRegex(output, '192.168.5')
self.assertRegex(output, '1492')
test-network: add tests for DHCP.RouteTable=
2019-02-11 13:38:54 +01:00
# issue #8726
print('## ip route show table main dev veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show table main dev veth99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
test-network: add tests for DHCP.RouteTable=
2019-02-11 13:38:54 +01:00
self.assertNotRegex(output, 'proto dhcp')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test-network: add tests for DHCP.RouteTable=
2019-02-11 13:38:54 +01:00
print('## ip route show table 211 dev veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show table 211 dev veth99')
test-network: add tests for DHCP.RouteTable=
2019-02-11 13:38:54 +01:00
print(output)
self.assertRegex(output, 'default via 192.168.5.1 proto dhcp')
self.assertRegex(output, '192.168.5.0/24 via 192.168.5.5 proto dhcp')
self.assertRegex(output, '192.168.5.1 proto dhcp scope link')
print('## dnsmasq log')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertTrue(search_words_in_dnsmasq_log('vendor class: SusantVendorTest', True))
self.assertTrue(search_words_in_dnsmasq_log('DHCPDISCOVER(veth-peer) 12:34:56:78:9a:bc'))
self.assertTrue(search_words_in_dnsmasq_log('client provides name: test-hostname'))
self.assertTrue(search_words_in_dnsmasq_log('26:mtu'))
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp6_client_settings_rapidcommit_true(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '12:34:56:78:9a:bc')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertTrue(search_words_in_dnsmasq_log('14:rapid-commit', True))
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp6_client_settings_rapidcommit_false(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-rapid-commit.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, '12:34:56:78:9a:bc')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertFalse(search_words_in_dnsmasq_log('14:rapid-commit', True))
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp_client_settings_anonymize(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-anonymize.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
self.assertFalse(search_words_in_dnsmasq_log('VendorClassIdentifier=SusantVendorTest', True))
self.assertFalse(search_words_in_dnsmasq_log('test-hostname'))
self.assertFalse(search_words_in_dnsmasq_log('26:mtu'))
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp_client_listen_port(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-listen-port.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq('--dhcp-alternate-port=67,5555')
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
# link become 'routable' when at least one protocol provide an valid address.
test-network: do not allow addresses in tentative state
2019-06-04 20:55:32 +02:00
self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99')
test-network: use dnsmasq with --dhcp-alternate-port option to test DHCP.ListenPort= Fixes #11675.
2019-02-09 13:14:16 +01:00
print(output)
self.assertRegex(output, '192.168.5.* dynamic')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
def test_dhcp_route_table_id(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-route-table.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show table 12')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'veth99 proto dhcp')
self.assertRegex(output, '192.168.5.1')
def test_dhcp_route_metric(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-route-metric.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show dev veth99')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
self.assertRegex(output, 'metric 24')
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
def test_dhcp_keep_configuration_dhcp(self):
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-keep-configuration-dhcp.network')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(0)
wait_online(['veth-peer:carrier'])
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
start_dnsmasq(lease_time='2m')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertRegex(output, r'192.168.5.*')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
self.assertRegex(output, r'192.168.5.*')
test-network: check link before starting dnsmasq
2018-12-06 15:14:57 +01:00
codespell: fix spelling errors
2019-04-27 02:22:40 +02:00
# Stopping dnsmasq as networkd won't be allowed to renew the DHCP lease.
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
stop_dnsmasq(dnsmasq_pid_file)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
# Sleep for 120 sec as the dnsmasq minimum lease time can only be set to 120
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
print('Wait for the dynamic address to be expired')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
time.sleep(125)
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
print('The lease address should be kept after lease expired')
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertRegex(output, r'192.168.5.*')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
print(output)
test-network: add tests for KeepConfiguration=
2019-06-03 06:21:13 +02:00
self.assertRegex(output, r'192.168.5.*')
check_output('systemctl stop systemd-networkd')
print('The lease address should be kept after networkd stopped')
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertRegex(output, r'192.168.5.*')
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
print(output)
self.assertRegex(output, r'192.168.5.*')
check_output('systemctl start systemd-networkd')
wait_online(['veth-peer:routable'])
print('Still the lease address should be kept after networkd restarted')
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertRegex(output, r'192.168.5.*')
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
print(output)
self.assertRegex(output, r'192.168.5.*')
def test_dhcp_keep_configuration_dhcp_on_stop(self):
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-keep-configuration-dhcp-on-stop.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq(lease_time='2m')
wait_online(['veth99:routable', 'veth-peer:routable'])
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertRegex(output, r'192.168.5.*')
stop_dnsmasq(dnsmasq_pid_file)
check_output('systemctl stop systemd-networkd')
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertRegex(output, r'192.168.5.*')
start_networkd(0)
wait_online(['veth-peer:routable'])
output = check_output('ip address show dev veth99 scope global')
print(output)
self.assertNotRegex(output, r'192.168.5.*')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
def test_dhcp_client_reuse_address_as_static(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
# link become 'routable' when at least one protocol provide an valid address.
test-network: do not allow addresses in tentative state
2019-06-04 20:55:32 +02:00
self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99 scope global')
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
print(output)
self.assertRegex(output, '192.168.5')
self.assertRegex(output, '2600::')
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
ipv4_address = re.search(r'192.168.5.[0-9]*/24', output)
ipv6_address = re.search(r'2600::[0-9a-f:]*/128', output)
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
static_network = '\n'.join(['[Match]', 'Name=veth99', '[Network]', 'IPv6AcceptRA=no', 'Address=' + ipv4_address.group(), 'Address=' + ipv6_address.group()])
print(static_network)
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
remove_unit_from_networkd_path(['dhcp-client.network'])
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
with open(os.path.join(network_unit_file_path, 'static.network'), mode='w') as f:
f.write(static_network)
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
# When networkd started, the links are already configured, so let's wait for 5 seconds
# the links to be re-configured.
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
start_networkd(5)
wait_online(['veth99:routable', 'veth-peer:routable'])
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope global')
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
print(output)
self.assertRegex(output, '192.168.5')
self.assertRegex(output, 'valid_lft forever preferred_lft forever')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope global')
test: add a testcase for #11458
2019-01-17 07:38:17 +01:00
print(output)
self.assertRegex(output, '2600::')
self.assertRegex(output, 'valid_lft forever preferred_lft forever')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
@expectedFailureIfModuleIsNotAvailable('vrf')
def test_dhcp_client_vrf(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-vrf.network',
'25-vrf.netdev', '25-vrf.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable', 'vrf99:carrier'])
test-network: use wait_online() instead of waiting for 10 seconds But some tests requires both IPv4 and IPv6 addresses are configured. Only in that case wait for addresses to be configured.
2019-05-24 06:59:34 +02:00
# link become 'routable' when at least one protocol provide an valid address.
test-network: do not allow addresses in tentative state
2019-06-04 20:55:32 +02:00
self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
print('## ip -d link show dev vrf99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -d link show dev vrf99')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
print(output)
self.assertRegex(output, 'vrf table 42')
print('## ip address show vrf vrf99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show vrf vrf99')
test-network: do not directly compare two results of "ip address" As it contains lifetime of the address.
2019-06-04 20:57:21 +02:00
print(output)
self.assertRegex(output, 'inet 169.254.[0-9]*.[0-9]*/16 brd 169.254.255.255 scope link veth99')
self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
self.assertRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)')
self.assertRegex(output, 'inet6 .* scope link')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
print('## ip address show dev veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
print(output)
self.assertRegex(output, 'inet 169.254.[0-9]*.[0-9]*/16 brd 169.254.255.255 scope link veth99')
self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
test-network: do not directly compare two results of "ip address" As it contains lifetime of the address.
2019-06-04 20:57:21 +02:00
self.assertRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
self.assertRegex(output, 'inet6 .* scope link')
print('## ip route show vrf vrf99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show vrf vrf99')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
print(output)
self.assertRegex(output, 'default via 192.168.5.1 dev veth99 proto dhcp src 192.168.5.')
self.assertRegex(output, 'default dev veth99 proto static scope link')
self.assertRegex(output, '169.254.0.0/16 dev veth99 proto kernel scope link src 169.254')
self.assertRegex(output, '192.168.5.0/24 dev veth99 proto kernel scope link src 192.168.5')
self.assertRegex(output, '192.168.5.0/24 via 192.168.5.5 dev veth99 proto dhcp')
self.assertRegex(output, '192.168.5.1 dev veth99 proto dhcp scope link src 192.168.5')
print('## ip route show table main dev veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route show table main dev veth99')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
print(output)
self.assertEqual(output, '')
test-network: use check_operstate() helper function where applicable
2019-05-15 11:40:49 +02:00
self.check_operstate('vrf99', 'carrier')
self.check_operstate('veth99', 'routable')
test-network: add tests for VRF=
2019-02-12 06:42:12 +01:00
test-network: add testcase for #1850
2019-02-27 11:10:47 +01:00
def test_dhcp_client_gateway_onlink_implicit(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
'dhcp-client-gateway-onlink-implicit.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq()
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: add testcase for #1850
2019-02-27 11:10:47 +01:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
test-network: add testcase for #1850
2019-02-27 11:10:47 +01:00
print(output)
self.assertRegex(output, '192.168.5')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route list dev veth99 10.0.0.0/8')
test-network: add testcase for #1850
2019-02-27 11:10:47 +01:00
print(output)
self.assertRegex(output, 'onlink')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip route list dev veth99 192.168.100.0/24')
test-network: add testcase for #1850
2019-02-27 11:10:47 +01:00
print(output)
self.assertRegex(output, 'onlink')
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
def test_dhcp_client_with_ipv4ll_fallback_with_dhcp_server(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
'dhcp-client-with-ipv4ll-fallback-with-dhcp-server.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq(lease_time='2m')
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
print(output)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope global dynamic')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope link')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertRegex(output, 'inet6 .* scope link')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope global dynamic')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope link')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertNotRegex(output, 'inet .* scope link')
print('Wait for the dynamic address to be expired')
time.sleep(130)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
print(output)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope global dynamic')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope link')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertRegex(output, 'inet6 .* scope link')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope global dynamic')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope link')
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
self.assertNotRegex(output, 'inet .* scope link')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
search_words_in_dnsmasq_log('DHCPOFFER', show_all=True)
test-network: add a test for LinkLocalAddressing=fallback
2019-05-04 01:29:45 +02:00
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
def test_dhcp_client_with_ipv4ll_fallback_without_dhcp_server(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
'dhcp-client-with-ipv4ll-fallback-without-dhcp-server.network')
start_networkd(0)
wait_online(['veth99:degraded', 'veth-peer:routable'])
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip address show dev veth99')
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
print(output)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope global dynamic')
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -6 address show dev veth99 scope link')
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
self.assertRegex(output, 'inet6 .* scope link')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope global dynamic')
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
self.assertNotRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope link')
test-network: add one more test for LinkLocalAddressing=fallback
2019-05-05 17:42:05 +02:00
self.assertRegex(output, 'inet .* scope link')
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
def test_dhcp_client_route_remove_on_renew(self):
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
'dhcp-client-ipv4-only-ipv6-disabled.network')
start_networkd(0)
wait_online(['veth-peer:carrier'])
start_dnsmasq(ipv4_range='192.168.5.100,192.168.5.199', lease_time='2m')
wait_online(['veth99:routable', 'veth-peer:routable'])
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
# test for issue #12490
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope global dynamic')
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
print(output)
self.assertRegex(output, 'inet 192.168.5.1[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
address1=None
for line in output.splitlines():
if 'brd 192.168.5.255 scope global dynamic veth99' in line:
address1 = line.split()[1].split('/')[0]
break
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 route show dev veth99')
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
print(output)
self.assertRegex(output, f'default via 192.168.5.1 proto dhcp src {address1} metric 1024')
self.assertRegex(output, f'192.168.5.1 proto dhcp scope link src {address1} metric 1024')
networkd-tests.py: remove some java-style boilerplate A class was used to put some utility functions under a namespace. But then this namespace was inherited into classes, so the namespace split was undone. Let's just define those functions in the module namespace. (The Utilities class with a few functions still remain, because of the unittest-style self.assert* craziness.)
2019-06-05 12:08:09 +02:00
stop_dnsmasq(dnsmasq_pid_file)
start_dnsmasq(ipv4_range='192.168.5.200,192.168.5.250', lease_time='2m')
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
print('Wait for the dynamic address to be expired')
time.sleep(130)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 address show dev veth99 scope global dynamic')
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
print(output)
self.assertRegex(output, 'inet 192.168.5.2[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
address2=None
for line in output.splitlines():
if 'brd 192.168.5.255 scope global dynamic veth99' in line:
address2 = line.split()[1].split('/')[0]
break
self.assertNotEqual(address1, address2)
networkd-tests.py: add helpers to common subprocess call patterns For normal shell calls, python syntax is quite verbose. We don't need to punish ourselves like that. In some places we would fork a shell to do argument splitting for us. We know that our arguments can be safely split on whitespace, so let's do that ourselves in all cases, without forking a shell. We also expect command output to be valid text, so let's always set universal_newlines=True. This makes things shorter and easier to read. Development is also easier because it's possible to paste many of the commands directly to/from a shell.
2019-06-05 11:43:28 +02:00
output = check_output('ip -4 route show dev veth99')
test-network: add tests for issue #12490
2019-05-24 04:39:26 +02:00
print(output)
self.assertNotRegex(output, f'default via 192.168.5.1 proto dhcp src {address1} metric 1024')
self.assertNotRegex(output, f'192.168.5.1 proto dhcp scope link src {address1} metric 1024')
self.assertRegex(output, f'default via 192.168.5.1 proto dhcp src {address2} metric 1024')
self.assertRegex(output, f'192.168.5.1 proto dhcp scope link src {address2} metric 1024')
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
if __name__ == '__main__':
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
parser = argparse.ArgumentParser()
parser.add_argument('--build-dir', help='Path to build dir', dest='build_dir')
parser.add_argument('--networkd', help='Path to systemd-networkd', dest='networkd_bin')
parser.add_argument('--wait-online', help='Path to systemd-networkd-wait-online', dest='wait_online_bin')
parser.add_argument('--networkctl', help='Path to networkctl', dest='networkctl_bin')
parser.add_argument('--valgrind', help='Enable valgrind', dest='use_valgrind', type=bool, nargs='?', const=True, default=use_valgrind)
parser.add_argument('--debug', help='Generate debugging logs', dest='enable_debug', type=bool, nargs='?', const=True, default=enable_debug)
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
parser.add_argument('--asan-options', help='ASAN options', dest='asan_options')
test-network: add --lsan-options option
2019-05-31 01:49:48 +02:00
parser.add_argument('--lsan-options', help='LSAN options', dest='lsan_options')
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
parser.add_argument('--ubsan-options', help='UBSAN options', dest='ubsan_options')
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
ns, args = parser.parse_known_args(namespace=unittest)
if ns.build_dir:
if ns.networkd_bin or ns.wait_online_bin or ns.networkctl_bin:
print('WARNING: --networkd, --wait-online, or --networkctl options are ignored when --build-dir is specified.')
networkd_bin = os.path.join(ns.build_dir, 'systemd-networkd')
wait_online_bin = os.path.join(ns.build_dir, 'systemd-networkd-wait-online')
networkctl_bin = os.path.join(ns.build_dir, 'networkctl')
else:
if ns.networkd_bin:
networkd_bin = ns.networkd_bin
if ns.wait_online_bin:
wait_online_bin = ns.wait_online_bin
if ns.networkctl_bin:
networkctl_bin = ns.networkctl_bin
use_valgrind = ns.use_valgrind
enable_debug = ns.enable_debug
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
asan_options = ns.asan_options
test-network: add --lsan-options option
2019-05-31 01:49:48 +02:00
lsan_options = ns.lsan_options
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
ubsan_options = ns.ubsan_options
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
if use_valgrind:
networkctl_cmd = ['valgrind', '--track-origins=yes', '--leak-check=full', '--show-leak-kinds=all', networkctl_bin]
wait_online_cmd = ['valgrind', '--track-origins=yes', '--leak-check=full', '--show-leak-kinds=all', wait_online_bin]
else:
networkctl_cmd = [networkctl_bin]
wait_online_cmd = [wait_online_bin]
if enable_debug:
env.update({ 'SYSTEMD_LOG_LEVEL' : 'debug' })
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
if asan_options:
env.update({ 'ASAN_OPTIONS' : asan_options })
test-network: add --lsan-options option
2019-05-31 01:49:48 +02:00
if lsan_options:
env.update({ 'LSAN_OPTIONS' : lsan_options })
test-network: make the test take ASAN and UBSAN options
2019-05-30 08:49:11 +02:00
if ubsan_options:
env.update({ 'UBSAN_OPTIONS' : ubsan_options })
test-network: make path to networkd or friends configurable
2019-05-30 05:33:57 +02:00
sys.argv[1:] = args
test: Add tests for networkd (#10147)
2018-09-29 14:36:25 +02:00
unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout,
verbosity=3))