Files
napalm-zyxel/tests/test_zyxel.py
T
Christian Manivong a37802cf88
driver / standard (pull_request) Successful in 16s
driver / lint (pull_request) Successful in 11s
driver / test (3.12) (pull_request) Successful in 49s
driver / types (pull_request) Successful in 51s
driver / test (3.13) (pull_request) Successful in 45s
driver / lowest (pull_request) Successful in 22s
driver / build (pull_request) Successful in 26s
driver / security (pull_request) Successful in 56s
CI / driver (pull_request) Successful in 2m13s
driver / publish (pull_request) Skipped
fix(driver): load_replace_candidate is None, not a stub that raises (NetOrk/netork#2503)
The driver cannot replace a device's configuration, and said so with a
load_replace_candidate that raised NotImplementedError. A method that only
raises still looks like a replace to anyone who asks whether the driver has
one: netOrk offered a config restore for these devices that could only fail.

None is how a driver switches off a method, the convention netOrk's
capability checks and napalm-device-types follow, so asking now says no.
Nothing in the driver calls it.
2026-11-13 21:45:24 +01:00

451 lines
17 KiB
Python

import json
from unittest.mock import MagicMock, patch
import pytest
import requests
from napalm.base.exceptions import ConnectionException
from napalm_zyxel import ZyxelVMGDriver
from tests.gateway import fixture
#: The recorded getBasicInformation answer of a VMG4005-B50A: model and firmware, no
#: serial number, host name, uptime, MAC or WAN state (#24). tests/gateway.py
MOCK_BASIC_INFO = fixture("getBasicInformation")
MOCK_RSA_KEY = (
"-----BEGIN PUBLIC KEY-----\n"
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw8kFmWQhFfTfL8eP\n"
"yGsqQw5g3n4R7pG9vLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzX\n"
"HmTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtR\n"
"q0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXH\n"
"mTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq\n"
"0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXHm\n"
"TZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0pQ+kCqWzXHmTZvLxKZJtRq0\n"
"pQIDAQAB\n"
"-----END PUBLIC KEY-----\n"
)
MOCK_LOGIN_RESPONSE = {
"content": "",
"iv": "QkJCQkJCQkJCQkJCQkJCQg==",
"key": "",
}
def _offline(driver: ZyxelVMGDriver) -> ZyxelVMGDriver:
"""*driver*, with an is_alive() that opens no socket (#17).
NAPALM's ``__del__`` asks ``is_alive()``, which connects to the gateway while the
driver has a session; many tests give it a mock one and never close it. The tests
of ``is_alive()`` itself call the class's method (and ``tests/test_is_alive.py``).
"""
driver.is_alive = lambda: {"is_alive": False} # type: ignore[method-assign]
return driver
class MockResponse:
def __init__(self, json_data, status_code=200, text=""):
self._json = json_data
self.status_code = status_code
self._text = text or json.dumps(json_data)
def json(self):
return self._json
@property
def text(self):
return self._text
def raise_for_status(self):
if self.status_code >= 400:
raise requests.HTTPError(f"HTTP {self.status_code}")
class TestZyxelVMGDriver:
def setup_method(self):
self.driver = _offline(ZyxelVMGDriver("192.168.1.1", "admin", "password"))
def _setup_mocked_http(self, monkeypatch_crypto=True):
session = MagicMock(spec=requests.Session)
session.verify = False
session.timeout = 60
session.trust_env = False
self.driver._session = session
self.driver._device_info = MOCK_BASIC_INFO
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
if "getRSAPublickKey" in url:
return MockResponse({"RSAPublicKey": MOCK_RSA_KEY})
if "cgi-bin/System?oid=snmp" in url: # tests/test_facts.py
return MockResponse([{"HostName": "VMG4005-B50A", "DomainName": "home"}])
if "cgi-bin/DAL?oid=cardpage_status" in url: # tests/test_facts.py
return MockResponse(fixture("cardpage_status"))
if "UserLogout" in url:
return MockResponse({})
return MockResponse({})
def mock_post(url, **kwargs):
if "UserLogin" in url:
return MockResponse(MOCK_LOGIN_RESPONSE)
return MockResponse({})
session.get.side_effect = mock_get
session.post.side_effect = mock_post
if monkeypatch_crypto:
crypto = MagicMock()
crypto.encrypt_json.return_value = {"content": "ENC", "iv": "IV", "key": ""}
crypto.decrypt_response.return_value = {"result": "ZCFG_SUCCESS", "sessionkey": "12345"}
crypto.encrypt_aes_key_with_rsa.return_value = "ENC_KEY"
crypto.aes_key = b"\x42" * 32
self.driver._crypto = crypto
self.driver._sessionkey = "12345"
def test_init(self):
assert self.driver.hostname == "192.168.1.1"
assert self.driver.username == "admin"
assert self.driver.password == "password"
assert self.driver.port == 80
assert self.driver.use_tls is False
assert self.driver.VENDOR == "Zyxel"
def test_open_success(self):
with patch("napalm_zyxel.zyxel_driver.ZyxelCrypto") as mock_crypto_cls:
mock_crypto = MagicMock()
mock_crypto.encrypt_json.return_value = {"content": "ENC", "iv": "IV", "key": ""}
mock_crypto.decrypt_response.return_value = {
"result": "ZCFG_SUCCESS",
"sessionkey": "12345",
}
mock_crypto.encrypt_aes_key_with_rsa.return_value = "ENC_KEY"
mock_crypto_cls.return_value = mock_crypto
session = MagicMock()
session.get.return_value = MockResponse(MOCK_BASIC_INFO)
session.post.return_value = MockResponse(MOCK_LOGIN_RESPONSE)
with patch.object(self.driver, "_session", session, create=False):
with patch.object(self.driver, "_get_rsa_pubkey", return_value=MOCK_RSA_KEY):
with patch.object(self.driver, "_get_basic_info", return_value=MOCK_BASIC_INFO):
self.driver._session = None
self.driver._crypto = None
self.driver._sessionkey = None
with patch("requests.Session", return_value=session):
self.driver.open()
assert self.driver._sessionkey == "12345"
assert self.driver._device_info == MOCK_BASIC_INFO
def test_open_failure_unreachable(self):
with patch("napalm_zyxel.zyxel_driver.ZyxelCrypto") as mock_crypto_cls:
mock_crypto = MagicMock()
mock_crypto_cls.return_value = mock_crypto
self.driver._session = None
with patch("requests.Session") as mock_session:
sess = MagicMock()
sess.get.side_effect = requests.ConnectionError("unreachable")
mock_session.return_value = sess
with pytest.raises(ConnectionException):
self.driver.open()
def test_close(self):
self._setup_mocked_http()
self.driver.close()
assert self.driver._session is None
assert self.driver._sessionkey is None
def test_is_alive(self):
self._setup_mocked_http()
with patch("socket.create_connection") as mock_conn:
mock_conn.return_value.__enter__.return_value = MagicMock()
assert ZyxelVMGDriver.is_alive(self.driver)["is_alive"] is True
def test_is_alive_fail(self):
self._setup_mocked_http()
with patch("socket.create_connection") as mock_conn:
mock_conn.side_effect = OSError("refused")
assert ZyxelVMGDriver.is_alive(self.driver)["is_alive"] is False
def test_get_facts(self):
self._setup_mocked_http()
facts = self.driver.get_facts()
assert facts["vendor"] == "Zyxel"
assert facts["model"] == "VMG4005-B50A"
assert facts["serial_number"] == "S000Y00000001"
assert facts["os_version"] == "V5.17(ABQA.3.1)C0"
assert facts["hostname"] == "VMG4005-B50A"
assert facts["fqdn"] == "VMG4005-B50A.home"
assert facts["uptime"] == 13554213
def test_get_port_forwards_empty(self):
self._setup_mocked_http()
self.driver._session.get.side_effect = None
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
return MockResponse({}, text="no forwards here")
self.driver._session.get.side_effect = mock_get
forwards = self.driver.get_port_forwards()
assert forwards == []
def test_get_hosts_empty(self):
self._setup_mocked_http()
self.driver._session.get.side_effect = None
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
return MockResponse({}, text="no dhcp here")
self.driver._session.get.side_effect = mock_get
hosts = self.driver.get_hosts()
assert hosts == []
def test_get_nat_translations_empty(self):
self._setup_mocked_http()
self.driver._session.get.side_effect = None
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
return MockResponse({}, text="")
self.driver._session.get.side_effect = mock_get
nat = self.driver.get_nat_translations()
assert nat == []
def test_get_vpn_tunnels(self):
self._setup_mocked_http()
assert self.driver.get_vpn_tunnels() == {}
def test_get_wireless_clients_empty(self):
self._setup_mocked_http()
self.driver._session.get.side_effect = None
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
return MockResponse({}, text="")
self.driver._session.get.side_effect = mock_get
assert self.driver.get_wireless_clients() == []
def test_get_ssids_empty(self):
self._setup_mocked_http()
self.driver._session.get.side_effect = None
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
return MockResponse({}, text="")
self.driver._session.get.side_effect = mock_get
assert self.driver.get_ssids() == {}
def test_get_radio_status_empty(self):
self._setup_mocked_http()
self.driver._session.get.side_effect = None
def mock_get(url, **kwargs):
if "getBasicInformation" in url:
return MockResponse(MOCK_BASIC_INFO)
return MockResponse({}, text="")
self.driver._session.get.side_effect = mock_get
assert self.driver.get_radio_status() == {}
def test_get_arp_table(self):
self._setup_mocked_http()
assert self.driver.get_arp_table() == []
def test_an_arp_entry_has_no_known_age(self):
"""The host list says a host is active, not when the gateway last saw it;
0.0 would read as "confirmed just now" (NetOrk/netork#1327)."""
self.driver.get_hosts = lambda: [
{
"mac": "aa:bb:cc:dd:ee:ff",
"ip": "192.168.1.33",
"hostname": "laptop",
"interface_type": "lan",
"is_active": True,
}
]
assert [e["age"] for e in self.driver.get_arp_table()] == [-1.0]
def test_reboot_host_is_the_contract_the_application_calls(self):
"""It was reboot(), which nothing looks for: the gateway could not be
restarted from the application (#5)."""
self.driver._dal_query = lambda name, data: {"result": "ZCFG_SUCCESS"}
assert self.driver.reboot_host() is None
def test_a_refused_reboot_raises(self):
self.driver._dal_query = lambda name, data: {"result": "ZCFG_FAIL"}
with pytest.raises(RuntimeError):
self.driver.reboot_host()
def test_run_device_action_and_reboot_are_gone(self):
assert not hasattr(type(self.driver), "run_device_action")
assert not hasattr(type(self.driver), "reboot")
def test_load_merge_candidate_raises(self):
self._setup_mocked_http()
with pytest.raises(NotImplementedError):
self.driver.load_merge_candidate()
def test_ping_not_implemented(self):
self._setup_mocked_http()
result = self.driver.ping("8.8.8.8")
assert "error" in result
def test_get_environment(self):
self._setup_mocked_http()
assert self.driver.get_environment() == {}
def test_dal_query_not_connected(self):
from napalm.base.exceptions import ConnectionClosedException
self.driver._session = None
with pytest.raises(ConnectionClosedException):
self.driver._dal_query("PINGTEST", {})
def test_parse_wireless_clients_dal(self):
self._setup_mocked_http()
data = [
{
"MACAddress": "11:22:33:44:55:66",
"SSID": "MyWiFi",
"Radio": "wlan0",
"Signal": -45,
"TxRate": 300.0,
"RxRate": 150.0,
"Uptime": 3600,
"IPAddress": "192.168.1.50",
}
]
result = self.driver._parse_wireless_clients_dal(data)
assert len(result) == 1
assert result[0]["mac"] == "11:22:33:44:55:66"
assert result[0]["signal"] == -45
assert result[0]["ip"] == "192.168.1.50"
def test_parse_ssids_dal(self):
self._setup_mocked_http()
data = [
{
"SSID": "MyWiFi",
"Radio": "wlan0",
"BSSID": "00:1a:2b:3c:4d:5e",
"Encryption": "WPA2",
"Enabled": True,
"Hidden": False,
"Clients": 3,
}
]
result = self.driver._parse_ssids_dal(data)
assert "MyWiFi" in result
assert result["MyWiFi"]["encryption"] == "WPA2"
assert result["MyWiFi"]["clients"] == 3
def test_get_config_is_left_to_napalms_stub(self):
"""A VMG has no configuration export: the driver must not override
get_config, so NAPALM's stub tells callers it is not supported. A stub
returning {} read as a backup that came back empty."""
from napalm.base import NetworkDriver
assert ZyxelVMGDriver.get_config is NetworkDriver.get_config
with pytest.raises(NotImplementedError):
self.driver.get_config()
def test_cli(self):
self._setup_mocked_http()
assert self.driver.cli(["show version"]) == {}
@pytest.mark.parametrize("switch_model", ["gs1920", "gs2210"])
def test_a_zyxel_switch_page_adds_no_evidence_for_this_gateway(switch_model):
"""GS1920 and GS2210 are Zyxel switches, not VMG gateways."""
page = f"zyxel {switch_model}-24hp web configurator"
matching = [
rule.pattern
for rule in ZyxelVMGDriver.HTTP_FINGERPRINT
if not rule.negative and rule.pattern != "zyxel" and rule.pattern in page
]
assert matching == []
class TestEveryRequestHasATimeout:
"""requests ignores a ``timeout`` attribute on a Session; it must go with each call."""
def _driver_with_session(self):
driver = _offline(ZyxelVMGDriver("192.168.1.1", "admin", "password", timeout=7))
session = MagicMock(spec=requests.Session)
session.get.return_value = MockResponse(MOCK_BASIC_INFO)
session.post.return_value = MockResponse(MOCK_LOGIN_RESPONSE)
session.put.return_value = MockResponse({})
return driver, session
@staticmethod
def _timeouts(session):
calls = session.get.call_args_list + session.post.call_args_list
calls += session.put.call_args_list
assert calls
return {call.kwargs.get("timeout") for call in calls}
def test_open_login_and_logout(self):
driver, session = self._driver_with_session()
crypto = MagicMock()
crypto.encrypt_json.return_value = {"content": "ENC", "iv": "IV", "key": ""}
crypto.decrypt_response.return_value = {"result": "ZCFG_SUCCESS", "sessionkey": "1"}
session.get.side_effect = lambda url, **kw: MockResponse(
{"RSAPublicKey": MOCK_RSA_KEY} if "getRSAPublickKey" in url else MOCK_BASIC_INFO
)
with (
patch("napalm_zyxel.zyxel_driver.ZyxelCrypto", return_value=crypto),
patch("napalm_zyxel.zyxel_driver.requests.Session", return_value=session),
):
driver.open()
driver.close()
assert self._timeouts(session) == {7}
def test_dal_query_and_page_fetch(self):
driver, session = self._driver_with_session()
driver._session = session
driver._sessionkey = "1"
driver._crypto = MagicMock()
driver._dal_query("LAN_HOSTS")
driver._fetch_page("Status.htm")
assert self._timeouts(session) == {7}
class TestPingReportsNoTargetAlive:
"""The DAL PINGTEST call only acknowledges the request; it carries no reply count."""
def _connected_driver(self):
driver = _offline(ZyxelVMGDriver("192.168.1.1", "admin", "password"))
driver._session = MagicMock(spec=requests.Session)
driver._session.put.return_value = MockResponse({})
driver._sessionkey = "1"
driver._crypto = MagicMock()
driver._crypto.decrypt_response.return_value = {"result": "ZCFG_SUCCESS"}
return driver
def test_the_driver_opts_out_of_ping_sweeps(self):
assert ZyxelVMGDriver.supports_ping() is False
def test_an_accepted_request_is_not_a_reply(self):
driver = self._connected_driver()
reply = driver.ping("192.0.2.77")
assert "success" not in reply
assert reply["error"]
assert driver._parse_ping_reply("192.0.2.77", reply)["alive"] is False
def test_ping_starts_no_diagnostic_on_the_gateway(self):
driver = self._connected_driver()
driver.ping("192.0.2.77")
driver._session.put.assert_not_called()