driver / lint (pull_request) Successful in 20s
driver / standard (pull_request) Successful in 20s
driver / types (pull_request) Successful in 1m8s
driver / test (3.13) (pull_request) Successful in 58s
driver / test (3.12) (pull_request) Successful in 1m6s
driver / lowest (pull_request) Successful in 26s
driver / build (pull_request) Successful in 36s
driver / security (pull_request) Successful in 1m5s
CI / driver (pull_request) Successful in 2m23s
driver / publish (pull_request) Skipped
get_facts read SerialNumber and SystemUpTime from getBasicInformation, which a VMG4005-B50A does not send, and reported "" and 0. The gateway has both in DeviceInfo of the DAL's cardpage_status, the answer the interfaces are read from. get_facts now reads that answer once and takes the interfaces, serial number and uptime from it. Model and firmware stay with getBasicInformation, which does carry them. Closes #27
514 lines
19 KiB
Python
514 lines
19 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
|
|
|
|
MOCK_BASIC_INFO = {
|
|
"ModelName": "VMG4005-B50A",
|
|
"SoftwareVersion": "V5.13(ABKS.1)C0",
|
|
"WanIp": "85.2.34.56",
|
|
"LanIp": "192.168.1.1",
|
|
"MacAddress": "00:1A:2B:3C:4D:5E",
|
|
"SystemUpTime": "1234567",
|
|
"WanAccessType": "VDSL",
|
|
"MaxUpstream": "30000000",
|
|
"MaxDownstream": "100000000",
|
|
}
|
|
|
|
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": "ZyxelVMG", "DomainName": "home"}])
|
|
if "cgi-bin/DAL?oid=cardpage_status" in url: # tests/test_facts.py
|
|
device = {"SerialNumber": "S220L12345678", "UpTime": 1234567}
|
|
return MockResponse({"result": "ZCFG_SUCCESS", "Object": [{"DeviceInfo": device}]})
|
|
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"] == "S220L12345678"
|
|
assert facts["os_version"] == "V5.13(ABKS.1)C0"
|
|
assert facts["hostname"] == "ZyxelVMG"
|
|
assert facts["fqdn"] == "ZyxelVMG.home"
|
|
assert facts["uptime"] == 1234567
|
|
|
|
def test_get_wan_status(self):
|
|
self._setup_mocked_http()
|
|
status = self.driver.get_wan_status()
|
|
assert status["is_connected"] is True
|
|
assert status["external_ip"] == "85.2.34.56"
|
|
assert status["connection_type"] == "VDSL"
|
|
|
|
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_replace_candidate_raises(self):
|
|
self._setup_mocked_http()
|
|
with pytest.raises(NotImplementedError):
|
|
self.driver.load_replace_candidate()
|
|
|
|
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_port_forwards_dal(self):
|
|
self._setup_mocked_http()
|
|
data = {
|
|
"NATPortMap": [
|
|
{
|
|
"Description": "Web Server",
|
|
"Protocol": "TCP",
|
|
"ExternalPort": 80,
|
|
"InternalIP": "192.168.1.10",
|
|
"InternalPort": 8080,
|
|
"Enabled": True,
|
|
}
|
|
]
|
|
}
|
|
result = self.driver._parse_port_forwards_dal(data)
|
|
assert len(result) == 1
|
|
assert result[0]["name"] == "Web Server"
|
|
assert result[0]["external_port"] == 80
|
|
assert result[0]["internal_ip"] == "192.168.1.10"
|
|
|
|
def test_parse_hosts_dal(self):
|
|
self._setup_mocked_http()
|
|
data = {
|
|
"LANHosts": [
|
|
{
|
|
"MACAddress": "aa:bb:cc:dd:ee:ff",
|
|
"IPAddress": "192.168.1.100",
|
|
"HostName": "laptop",
|
|
"InterfaceType": "lan",
|
|
"Active": True,
|
|
}
|
|
]
|
|
}
|
|
result = self.driver._parse_hosts_dal(data)
|
|
assert len(result) == 1
|
|
assert result[0]["mac"] == "aa:bb:cc:dd:ee:ff"
|
|
assert result[0]["ip"] == "192.168.1.100"
|
|
assert result[0]["hostname"] == "laptop"
|
|
|
|
def test_parse_wireless_clients_dal(self):
|
|
self._setup_mocked_http()
|
|
data = {
|
|
"assoc": [
|
|
{
|
|
"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 = {
|
|
"ssids": [
|
|
{
|
|
"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()
|