driver / types (pull_request) Successful in 1m0s
driver / standard (pull_request) Successful in 16s
driver / lint (pull_request) Successful in 15s
driver / test (3.12) (pull_request) Successful in 1m9s
driver / test (3.13) (pull_request) Successful in 1m3s
driver / lowest (pull_request) Successful in 32s
driver / build (pull_request) Successful in 44s
driver / security (pull_request) Successful in 1m19s
CI / driver (pull_request) Successful in 2m56s
driver / publish (pull_request) Skipped
Fixtures, docstring examples and the README use neutral host names (ap-01, ap-02) and addresses from the documentation ranges 192.0.2.0/24, 198.51.100.0/24 and 203.0.113.0/24, mapped one to one so every test keeps its meaning: the management network test still has its address inside that network, a route still covers its prefix. Loopback, the wildcard address and netmasks are unchanged.
647 lines
22 KiB
Python
647 lines
22 KiB
Python
"""Time sync on OpenWrt (napalm-device-types ``TimeSyncMixin``, NetOrk/netork#2364).
|
|
|
|
OpenWrt keeps both values in UCI's ``system`` config: the servers in the
|
|
``system.ntp.server`` list, which sysntpd hands to BusyBox ntpd, and the zone twice --
|
|
``zonename`` (the IANA name, as LuCI writes it: with spaces for underscores) and
|
|
``timezone``, the POSIX rule libc reads as ``TZ``. The rule is the one that counts
|
|
(netOrk#1849: an IANA name in ``timezone`` left the AP on UTC).
|
|
|
|
The device is a fake ``uci`` behind ``run_command``: it renders ``uci -q show system``
|
|
the way uci prints it, and applies the ``uci set``/``delete``/``add_list`` lines a
|
|
write sends, so the template's ``verify`` step reads back what was written. Behind it
|
|
is netifd's ``ubus call network.interface dump``, where a DHCP lease's NTP servers
|
|
(option 42) are ``data.ntpserver`` -- sysntpd hands them to ntpd too while
|
|
``use_dhcp`` is on, and they count (NetOrk/netork#2380).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import shlex
|
|
from typing import Any
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
from napalm_device_types import CommandResult
|
|
from napalm_device_types.posix_tz import UnknownTimezone, posix_tz
|
|
from napalm_device_types.time_sync import TIME_SYNC_VALUES
|
|
|
|
from napalm_openwrt.openwrt import OpenWrtDriver
|
|
from napalm_openwrt.time_sync_mixin import DHCP_MARK, parse_system_uci, zone_for_rule
|
|
|
|
# ``uci show system`` of OpenWrt 23.05 out of the box: zonename 'UTC', the rule GMT0,
|
|
# the four pool servers as a list.
|
|
STOCK = """\
|
|
system.@system[0]=system
|
|
system.@system[0].hostname='OpenWrt'
|
|
system.@system[0].timezone='GMT0'
|
|
system.@system[0].zonename='UTC'
|
|
system.@system[0].ttylogin='0'
|
|
system.@system[0].log_size='128'
|
|
system.@system[0].urandom_seed='0'
|
|
system.ntp=timeserver
|
|
system.ntp.enabled='1'
|
|
system.ntp.enable_server='0'
|
|
system.ntp.server='0.openwrt.pool.ntp.org' '1.openwrt.pool.ntp.org' '2.openwrt.pool.ntp.org' '3.openwrt.pool.ntp.org'
|
|
"""
|
|
|
|
# An AP configured through LuCI (the reading of the get_system_config fixture in test_driver.py).
|
|
LUCI_BERLIN = """\
|
|
system.@system[0]=system
|
|
system.@system[0].hostname='ap-01'
|
|
system.@system[0].timezone='CET-1CEST,M3.5.0,M10.5.0/3'
|
|
system.@system[0].zonename='Europe/Berlin'
|
|
system.@system[0].log_remote='1'
|
|
system.@system[0].log_ip='192.0.2.40'
|
|
system.ntp=timeserver
|
|
system.ntp.server='0.openwrt.pool.ntp.org' '1.openwrt.pool.ntp.org'
|
|
"""
|
|
|
|
# LuCI's zone names have spaces where the IANA names have underscores.
|
|
LUCI_NEW_YORK = """\
|
|
system.@system[0]=system
|
|
system.@system[0].timezone='EST5EDT,M3.2.0,M11.1.0'
|
|
system.@system[0].zonename='America/New York'
|
|
system.ntp=timeserver
|
|
system.ntp.server='203.0.113.10'
|
|
"""
|
|
|
|
# netOrk#1849: the IANA name written as the rule. libc cannot read it; the AP runs on UTC.
|
|
NAME_AS_RULE = """\
|
|
system.@system[0]=system
|
|
system.@system[0].timezone='Europe/Berlin'
|
|
system.@system[0].zonename='Europe/Berlin'
|
|
system.ntp=timeserver
|
|
system.ntp.server='203.0.113.10'
|
|
"""
|
|
|
|
# A server list kept as one option, the servers apart by spaces: sysntpd splits it.
|
|
ONE_OPTION = """\
|
|
system.@system[0]=system
|
|
system.@system[0].timezone='UTC'
|
|
system.ntp=timeserver
|
|
system.ntp.server='0.openwrt.pool.ntp.org 1.openwrt.pool.ntp.org'
|
|
system.ntp.enabled='1'
|
|
"""
|
|
|
|
|
|
def _interface(name: str, ntpserver: str | None = None, **more: Any) -> dict[str, Any]:
|
|
"""One interface of ``ubus call network.interface dump``, as netifd prints it."""
|
|
data = {} if ntpserver is None else {"ntpserver": ntpserver}
|
|
return {"interface": name, "up": True, "proto": "dhcp", "data": data, **more}
|
|
|
|
|
|
#: A router whose WAN lease brings two NTP servers (udhcpc's ``ntpsrv``, apart by
|
|
#: spaces, as /lib/netifd/dhcp.script stores it) and a LAN of its own.
|
|
LEASE = {
|
|
"interface": [
|
|
_interface("lan", proto="static"),
|
|
_interface("wan", "192.0.2.1 192.0.2.2", leasetime=43200),
|
|
_interface("wan6", proto="dhcpv6"),
|
|
]
|
|
}
|
|
|
|
|
|
def _render(sections: list[tuple[str, str, dict[str, list[str] | str]]]) -> str:
|
|
"""*sections* as ``uci show system`` prints them."""
|
|
lines = []
|
|
for name, kind, options in sections:
|
|
lines.append(f"system.{name}={kind}")
|
|
for option, value in options.items():
|
|
values = value if isinstance(value, list) else [value]
|
|
lines.append(f"system.{name}.{option}=" + " ".join(_quoted(v) for v in values))
|
|
return "\n".join(lines) + "\n"
|
|
|
|
|
|
def _quoted(value: str) -> str:
|
|
"""*value* in single quotes, a quote in it as ``'\\''``: how uci prints every value."""
|
|
return "'" + value.replace("'", "'\\''") + "'"
|
|
|
|
|
|
def _parse(output: str) -> list[tuple[str, str, dict[str, list[str] | str]]]:
|
|
"""``uci show system`` as the fake's state (a list is a list, an option a string)."""
|
|
sections: list[tuple[str, str, dict[str, list[str] | str]]] = []
|
|
for line in output.splitlines():
|
|
key, _, raw = line.partition("=")
|
|
parts = key.split(".")
|
|
if len(parts) == 2:
|
|
sections.append((parts[1], raw, {}))
|
|
continue
|
|
values = shlex.split(raw)
|
|
option: list[str] | str = values if raw.count("'") > 2 else values[0]
|
|
next(s for s in sections if s[0] == parts[1])[2][parts[2]] = option
|
|
return sections
|
|
|
|
|
|
class _Uci:
|
|
"""A router's ``system`` config behind ``run_command``; keeps every command it ran."""
|
|
|
|
def __init__(
|
|
self, show: str = STOCK, fail: str = "", dump: dict[str, Any] | str | None = None
|
|
) -> None:
|
|
self.sections = _parse(show)
|
|
self.fail = fail
|
|
self.dump = {"interface": []} if dump is None else dump
|
|
self.ran: list[tuple[str, bool]] = []
|
|
|
|
def writes(self) -> list[str]:
|
|
return [c for c, _ in self.ran if not c.startswith("uci -q show system")]
|
|
|
|
def __call__(
|
|
self,
|
|
command: str,
|
|
*,
|
|
privileged: bool = False,
|
|
timeout: float = 60,
|
|
stdin: bytes | None = None,
|
|
) -> CommandResult:
|
|
self.ran.append((command, privileged))
|
|
if command == "uci -q show system":
|
|
return CommandResult(_render(self.sections), "", 0)
|
|
if command.startswith("uci -q show system &&"):
|
|
assert "ubus call network.interface dump" in command
|
|
dump = self.dump if isinstance(self.dump, str) else json.dumps(self.dump, indent=1)
|
|
return CommandResult(f"{_render(self.sections)}{DHCP_MARK}\n{dump}\n", "", 0)
|
|
for part in command.split(" && "):
|
|
if self.fail and self.fail in part:
|
|
return CommandResult("", f"{self.fail}: failed", 1)
|
|
words = shlex.split(part)
|
|
if words[0] == "uci":
|
|
self._uci(words[1:])
|
|
return CommandResult("", "", 0)
|
|
|
|
def _section(self, name: str) -> dict[str, list[str] | str]:
|
|
return next(s for s in self.sections if s[0] == name)[2]
|
|
|
|
def _uci(self, args: list[str]) -> None:
|
|
verb, rest = args[0], args[1:]
|
|
if verb == "commit":
|
|
return
|
|
key, _, value = rest[0].partition("=")
|
|
_, section, *option = key.split(".")
|
|
if verb == "set" and not option:
|
|
self.sections.append((section, value, {}))
|
|
elif verb == "set":
|
|
self._section(section)[option[0]] = value
|
|
elif verb == "add_list":
|
|
options = self._section(section)
|
|
kept = options.get(option[0], [])
|
|
options[option[0]] = [*([kept] if isinstance(kept, str) else kept), value]
|
|
elif verb == "delete":
|
|
del self._section(section)[option[0]]
|
|
else: # pragma: no cover - a command the driver does not send
|
|
raise AssertionError(args)
|
|
|
|
|
|
def _driver(uci: _Uci, username: str = "root") -> OpenWrtDriver:
|
|
with patch("napalm_openwrt.openwrt.ConnectHandler"):
|
|
drv = OpenWrtDriver(hostname="192.0.2.15", username=username, password="")
|
|
drv.device = MagicMock()
|
|
drv.run_command = uci # type: ignore[method-assign]
|
|
return drv
|
|
|
|
|
|
def _read(show: str, dump: dict[str, Any] | str | None = None) -> dict[str, Any]:
|
|
return dict(_driver(_Uci(show, dump=dump)).get_time_sync())
|
|
|
|
|
|
# -- the driver takes part ----------------------------------------------------------------------
|
|
|
|
|
|
def test_the_driver_reads_and_writes_both_values():
|
|
drv = _driver(_Uci())
|
|
|
|
assert callable(getattr(drv, "get_time_sync", None))
|
|
assert callable(getattr(drv, "configure_time_sync", None))
|
|
assert drv.time_sync_writes == TIME_SYNC_VALUES
|
|
|
|
|
|
# -- reading ------------------------------------------------------------------------------------
|
|
|
|
|
|
def test_a_stock_router_reads_its_pool_servers_and_utc():
|
|
# zonename 'UTC' with the rule GMT0: the same time, so the name stands.
|
|
assert _read(STOCK) == {
|
|
"ntp_servers": [
|
|
"0.openwrt.pool.ntp.org",
|
|
"1.openwrt.pool.ntp.org",
|
|
"2.openwrt.pool.ntp.org",
|
|
"3.openwrt.pool.ntp.org",
|
|
],
|
|
"timezone": "UTC",
|
|
"synchronized": None,
|
|
"daemon": None,
|
|
"dhcp_ntp_servers": [],
|
|
}
|
|
|
|
|
|
def test_the_read_is_one_round_trip_as_the_login_user():
|
|
uci = _Uci()
|
|
_driver(uci).get_time_sync()
|
|
|
|
((command, privileged),) = uci.ran
|
|
assert command.startswith("uci -q show system &&")
|
|
assert privileged is False
|
|
|
|
|
|
# -- reading what DHCP brought ------------------------------------------------------------------
|
|
|
|
|
|
def test_a_lease_s_ntp_servers_are_read_apart_from_the_configured_ones():
|
|
reading = _read(STOCK, LEASE)
|
|
|
|
assert reading["dhcp_ntp_servers"] == ["192.0.2.1", "192.0.2.2"]
|
|
assert reading["ntp_servers"] == [
|
|
"0.openwrt.pool.ntp.org",
|
|
"1.openwrt.pool.ntp.org",
|
|
"2.openwrt.pool.ntp.org",
|
|
"3.openwrt.pool.ntp.org",
|
|
]
|
|
|
|
|
|
def test_every_interface_s_lease_counts_in_netifd_s_order_each_once():
|
|
dump = {
|
|
"interface": [
|
|
_interface("wan", "192.0.2.1"),
|
|
_interface("iot", "198.51.100.1 192.0.2.1"),
|
|
]
|
|
}
|
|
|
|
assert _read(STOCK, dump)["dhcp_ntp_servers"] == ["192.0.2.1", "198.51.100.1"]
|
|
|
|
|
|
def test_an_interface_without_a_lease_or_with_an_odd_one_brings_nothing():
|
|
dump = {
|
|
"interface": [
|
|
"wan",
|
|
{"interface": "wan", "data": "192.0.2.1"},
|
|
{"interface": "wan", "data": {"ntpserver": ["192.0.2.1"]}},
|
|
{"interface": "wan"},
|
|
_interface("iot", "198.51.100.1"),
|
|
]
|
|
}
|
|
|
|
assert _read(STOCK, dump)["dhcp_ntp_servers"] == ["198.51.100.1"]
|
|
|
|
|
|
def test_dhcp_interface_names_the_interfaces_whose_leases_count():
|
|
show = STOCK + "system.ntp.dhcp_interface='iot'\n"
|
|
dump = {
|
|
"interface": [
|
|
_interface("wan", "192.0.2.1"),
|
|
_interface("iot", "198.51.100.1"),
|
|
]
|
|
}
|
|
|
|
assert _read(show, dump)["dhcp_ntp_servers"] == ["198.51.100.1"]
|
|
|
|
|
|
def test_use_dhcp_off_takes_nothing_from_a_lease():
|
|
show = STOCK + "system.ntp.use_dhcp='0'\n"
|
|
|
|
assert _read(show, LEASE)["dhcp_ntp_servers"] == []
|
|
|
|
|
|
def test_a_disabled_client_takes_nothing_from_a_lease():
|
|
show = STOCK.replace("system.ntp.enabled='1'", "system.ntp.enabled='0'")
|
|
|
|
assert _read(show, LEASE)["dhcp_ntp_servers"] == []
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"dump", ["", "Command failed: Permission denied", "{", "[]", '{"interface": {}}']
|
|
)
|
|
def test_without_netifd_s_answer_dhcp_is_unknown(dump):
|
|
assert _read(STOCK, dump)["dhcp_ntp_servers"] is None
|
|
|
|
|
|
def test_without_netifd_s_answer_a_router_that_takes_nothing_from_dhcp_still_says_so():
|
|
show = STOCK + "system.ntp.use_dhcp='0'\n"
|
|
|
|
assert _read(show, "")["dhcp_ntp_servers"] == []
|
|
|
|
|
|
def test_a_zone_set_through_luci_reads_by_its_name():
|
|
reading = _read(LUCI_BERLIN)
|
|
|
|
assert reading["timezone"] == "Europe/Berlin"
|
|
assert reading["ntp_servers"] == ["0.openwrt.pool.ntp.org", "1.openwrt.pool.ntp.org"]
|
|
|
|
|
|
def test_luci_spaces_read_as_the_iana_underscores():
|
|
assert _read(LUCI_NEW_YORK)["timezone"] == "America/New_York"
|
|
|
|
|
|
def test_a_name_whose_rule_is_not_in_force_is_not_read_as_the_zone():
|
|
# netOrk#1849: the AP runs on UTC; reading Europe/Berlin would hide that.
|
|
assert _read(NAME_AS_RULE)["timezone"] is None
|
|
|
|
|
|
def test_a_rule_without_a_name_reads_as_the_one_zone_that_has_it():
|
|
show = "system.@system[0]=system\nsystem.@system[0].timezone='IST-5:30'\n"
|
|
|
|
assert _read(show)["timezone"] == "Asia/Kolkata"
|
|
|
|
|
|
def test_a_rule_many_zones_share_reads_as_no_zone():
|
|
# Berlin, Paris, Madrid, ... all have this rule: which one is not the driver's to guess.
|
|
show = "system.@system[0]=system\nsystem.@system[0].timezone='CET-1CEST,M3.5.0,M10.5.0/3'\n"
|
|
|
|
assert _read(show)["timezone"] is None
|
|
|
|
|
|
def test_a_section_without_a_rule_runs_on_utc():
|
|
# /etc/init.d/system defaults the rule to UTC.
|
|
assert _read("system.@system[0]=system\n")["timezone"] == "Etc/UTC"
|
|
|
|
|
|
def test_no_system_section_reads_no_zone():
|
|
assert _read("")["timezone"] is None
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("rule", "zone"),
|
|
[
|
|
("UTC", "Etc/UTC"),
|
|
("UTC0", "Etc/UTC"),
|
|
("<+0545>-5:45", "Asia/Kathmandu"),
|
|
("NZST-12NZDT,M9.5.0,M4.1.0/3", "Pacific/Auckland"),
|
|
("GMT0", None), # Abidjan, Monrovia, Etc/GMT, ...
|
|
("<-00>0", None), # Factory: the zone is not known
|
|
("Europe/Berlin", None),
|
|
("", None),
|
|
],
|
|
)
|
|
def test_zone_for_rule(rule, zone):
|
|
assert zone_for_rule(rule) == zone
|
|
|
|
|
|
def test_a_server_list_kept_as_one_option_is_split_as_sysntpd_does():
|
|
assert _read(ONE_OPTION)["ntp_servers"] == [
|
|
"0.openwrt.pool.ntp.org",
|
|
"1.openwrt.pool.ntp.org",
|
|
]
|
|
|
|
|
|
def test_a_disabled_client_has_no_servers():
|
|
# sysntpd starts no ntpd: the list names sources the clock does not take time from.
|
|
show = STOCK.replace("system.ntp.enabled='1'", "system.ntp.enabled='0'")
|
|
|
|
assert _read(show)["ntp_servers"] == []
|
|
|
|
|
|
def test_no_ntp_section_has_no_servers():
|
|
show = "system.@system[0]=system\nsystem.@system[0].timezone='UTC'\n"
|
|
|
|
assert _read(show)["ntp_servers"] == []
|
|
|
|
|
|
def test_a_line_uci_would_not_print_is_passed_over():
|
|
reading = parse_system_uci(LUCI_BERLIN + "system.@system[0].zonename='Europe/Paris\n")
|
|
|
|
assert reading.zone == "Europe/Berlin"
|
|
|
|
|
|
def test_a_failed_read_raises():
|
|
drv = _driver(_Uci())
|
|
drv.run_command = lambda *a, **k: CommandResult("", "uci: Entry not found", 1) # type: ignore[method-assign]
|
|
|
|
with pytest.raises(RuntimeError, match="Entry not found"):
|
|
drv.get_time_sync()
|
|
|
|
|
|
# -- get_ntp_servers agrees ---------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.parametrize("show", [STOCK, LUCI_BERLIN, ONE_OPTION, NAME_AS_RULE])
|
|
def test_get_ntp_servers_names_the_same_servers(show):
|
|
drv = _driver(_Uci(show))
|
|
|
|
assert list(drv.get_ntp_servers()) == drv.get_time_sync()["ntp_servers"]
|
|
|
|
|
|
def test_get_ntp_servers_reads_every_server_of_a_list():
|
|
# It used to keep only the first of 'a' 'b' 'c'.
|
|
assert len(_driver(_Uci(STOCK)).get_ntp_servers()) == 4
|
|
|
|
|
|
def test_the_peers_are_the_servers():
|
|
drv = _driver(_Uci(STOCK))
|
|
|
|
assert drv.get_ntp_peers() == drv.get_ntp_servers()
|
|
|
|
|
|
def test_get_ntp_servers_of_a_disabled_client_is_empty():
|
|
show = STOCK.replace("system.ntp.enabled='1'", "system.ntp.enabled='0'")
|
|
|
|
assert _driver(_Uci(show)).get_ntp_servers() == {}
|
|
|
|
|
|
# -- writing the servers ------------------------------------------------------------------------
|
|
|
|
|
|
def test_the_servers_replace_the_list_and_ntpd_restarts():
|
|
uci = _Uci(STOCK)
|
|
result = _driver(uci).configure_time_sync(ntp_servers=["203.0.113.10", "ntp.example.org"])
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert [s["step"] for s in result["steps"]] == ["ntp_servers", "verify"]
|
|
assert uci._section("ntp")["server"] == ["203.0.113.10", "ntp.example.org"]
|
|
(write,) = uci.writes()
|
|
assert write.endswith(
|
|
"uci commit system && /etc/init.d/sysntpd enable && /etc/init.d/sysntpd restart"
|
|
)
|
|
assert all(privileged for c, privileged in uci.ran if c in uci.writes())
|
|
|
|
|
|
def test_writing_servers_leaves_the_ones_dhcp_brings():
|
|
# DHCP option 42 counts (NetOrk/netork#2380): sysntpd keeps adding a lease's servers.
|
|
uci = _Uci(STOCK, dump=LEASE)
|
|
result = _driver(uci).configure_time_sync(ntp_servers=["203.0.113.10"])
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert "use_dhcp" not in uci._section("ntp")
|
|
assert "use_dhcp" not in uci.writes()[0]
|
|
|
|
|
|
def test_writing_servers_keeps_use_dhcp_as_the_router_has_it():
|
|
uci = _Uci(STOCK + "system.ntp.use_dhcp='0'\n")
|
|
result = _driver(uci).configure_time_sync(ntp_servers=["203.0.113.10"])
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert uci._section("ntp")["use_dhcp"] == "0"
|
|
assert "use_dhcp" not in uci.writes()[0]
|
|
|
|
|
|
def test_the_same_servers_with_dhcp_on_write_nothing():
|
|
uci = _Uci(LUCI_BERLIN, dump=LEASE)
|
|
result = _driver(uci).configure_time_sync(
|
|
ntp_servers=["0.openwrt.pool.ntp.org", "1.openwrt.pool.ntp.org"]
|
|
)
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert uci.writes() == []
|
|
|
|
|
|
def test_writing_servers_enables_a_disabled_client():
|
|
uci = _Uci(STOCK.replace("system.ntp.enabled='1'", "system.ntp.enabled='0'"))
|
|
result = _driver(uci).configure_time_sync(ntp_servers=["203.0.113.10"])
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert uci._section("ntp")["enabled"] == "1"
|
|
assert "/etc/init.d/sysntpd enable" in uci.writes()[0]
|
|
|
|
|
|
def test_a_missing_ntp_section_is_made():
|
|
uci = _Uci("system.@system[0]=system\nsystem.@system[0].timezone='UTC'\n")
|
|
result = _driver(uci).configure_time_sync(ntp_servers=["203.0.113.10"])
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert ("ntp", "timeserver") in [(s[0], s[1]) for s in uci.sections]
|
|
assert "uci delete system.ntp.server" not in uci.writes()[0]
|
|
|
|
|
|
def test_the_same_servers_again_write_nothing():
|
|
# netOrk aligns on every poll: an aligned router must not restart ntpd each time.
|
|
uci = _Uci(STOCK)
|
|
drv = _driver(uci)
|
|
drv.configure_time_sync(ntp_servers=["203.0.113.10", "203.0.113.11"])
|
|
uci.ran.clear()
|
|
|
|
result = drv.configure_time_sync(ntp_servers=["203.0.113.10", "203.0.113.11"])
|
|
|
|
assert result["success"] is True
|
|
assert uci.writes() == []
|
|
assert "already" in result["steps"][0]["output"]
|
|
|
|
|
|
def test_the_same_servers_in_another_order_are_written():
|
|
uci = _Uci(LUCI_BERLIN)
|
|
_driver(uci).configure_time_sync(
|
|
ntp_servers=["1.openwrt.pool.ntp.org", "0.openwrt.pool.ntp.org"]
|
|
)
|
|
|
|
assert uci._section("ntp")["server"] == ["1.openwrt.pool.ntp.org", "0.openwrt.pool.ntp.org"]
|
|
|
|
|
|
def test_a_refused_uci_write_restarts_nothing():
|
|
uci = _Uci(STOCK, fail="uci commit system")
|
|
result = _driver(uci).configure_time_sync(ntp_servers=["203.0.113.10"])
|
|
|
|
assert result["success"] is False
|
|
assert result["steps"][-1]["step"] == "ntp_servers"
|
|
assert "failed" in result["output"]
|
|
|
|
|
|
def test_a_login_other_than_root_writes_nothing():
|
|
uci = _Uci(STOCK)
|
|
drv = _driver(uci, username="admin")
|
|
drv.run_command = lambda c, **k: ( # type: ignore[method-assign]
|
|
drv._check_privilege(k.get("privileged", False)) or uci(c, **k)
|
|
)
|
|
|
|
result = drv.configure_time_sync(ntp_servers=["203.0.113.10"])
|
|
|
|
assert result["success"] is False
|
|
assert "no sudo" in result["output"]
|
|
assert uci.writes() == []
|
|
|
|
|
|
# -- writing the zone ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_the_zone_is_written_as_name_and_rule():
|
|
uci = _Uci(STOCK)
|
|
result = _driver(uci).configure_time_sync(timezone="Europe/Berlin")
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert [s["step"] for s in result["steps"]] == ["timezone", "verify"]
|
|
system = uci._section("@system[0]")
|
|
assert system["zonename"] == "Europe/Berlin"
|
|
assert system["timezone"] == "CET-1CEST,M3.5.0,M10.5.0/3"
|
|
|
|
|
|
def test_the_zone_applies_to_the_system_and_to_logd():
|
|
# /etc/init.d/system reload writes /tmp/TZ; logd reads the zone when it starts.
|
|
uci = _Uci(STOCK)
|
|
_driver(uci).configure_time_sync(timezone="Europe/Berlin")
|
|
|
|
(write,) = uci.writes()
|
|
assert write.endswith(
|
|
"uci commit system && /etc/init.d/system reload && /etc/init.d/log restart"
|
|
)
|
|
assert "sysntpd" not in write
|
|
|
|
|
|
def test_a_zone_name_is_written_as_luci_does():
|
|
uci = _Uci(STOCK)
|
|
result = _driver(uci).configure_time_sync(timezone="America/New_York")
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert uci._section("@system[0]")["zonename"] == "America/New York"
|
|
assert uci._section("@system[0]")["timezone"] == posix_tz("America/New_York")
|
|
|
|
|
|
def test_a_rule_with_quoted_names_is_one_shell_word():
|
|
uci = _Uci(STOCK)
|
|
_driver(uci).configure_time_sync(timezone="Asia/Kathmandu")
|
|
|
|
assert uci._section("@system[0]")["timezone"] == "<+0545>-5:45"
|
|
|
|
|
|
def test_the_name_as_rule_of_1849_is_repaired():
|
|
uci = _Uci(NAME_AS_RULE)
|
|
result = _driver(uci).configure_time_sync(timezone="Europe/Berlin")
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert uci._section("@system[0]")["timezone"] == "CET-1CEST,M3.5.0,M10.5.0/3"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("show", "zone"),
|
|
[(LUCI_BERLIN, "Europe/Berlin"), (LUCI_NEW_YORK, "America/New_York"), (STOCK, "UTC")],
|
|
)
|
|
def test_the_zone_it_has_writes_nothing(show, zone):
|
|
# The stock GMT0 is UTC's time under another name: no rewrite on every poll.
|
|
uci = _Uci(show)
|
|
result = _driver(uci).configure_time_sync(timezone=zone)
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert uci.writes() == []
|
|
|
|
|
|
def test_a_zone_twice_writes_once():
|
|
uci = _Uci(STOCK)
|
|
drv = _driver(uci)
|
|
drv.configure_time_sync(timezone="Pacific/Auckland")
|
|
drv.configure_time_sync(timezone="Pacific/Auckland")
|
|
|
|
assert len(uci.writes()) == 1
|
|
|
|
|
|
def test_both_values_in_one_run():
|
|
uci = _Uci(STOCK)
|
|
result = _driver(uci).configure_time_sync(
|
|
ntp_servers=["203.0.113.10"], timezone="Europe/Berlin"
|
|
)
|
|
|
|
assert result["success"] is True, result["output"]
|
|
assert [s["step"] for s in result["steps"]] == ["ntp_servers", "timezone", "verify"]
|
|
|
|
|
|
def test_a_zone_without_a_rule_is_not_written():
|
|
# The template lets only zones of the database through; the step does not rely on it.
|
|
uci = _Uci(STOCK)
|
|
outcome = _driver(uci)._write_time_zone("Mars/Olympus_Mons")
|
|
|
|
assert outcome["ok"] is False
|
|
assert uci.ran == []
|
|
|
|
|
|
def test_a_posix_rule_as_zone_is_refused_before_anything_runs():
|
|
uci = _Uci(STOCK)
|
|
|
|
with pytest.raises(UnknownTimezone):
|
|
_driver(uci).configure_time_sync(timezone="CET-1CEST,M3.5.0,M10.5.0/3")
|
|
assert uci.ran == []
|