driver / standard (pull_request) Successful in 17s
driver / lint (pull_request) Successful in 16s
driver / types (pull_request) Successful in 1m13s
driver / test (3.12) (pull_request) Successful in 4m9s
driver / test (3.13) (pull_request) Successful in 4m1s
driver / lowest (pull_request) Successful in 3m33s
driver / build (pull_request) Successful in 30s
driver / security (pull_request) Successful in 1m6s
CI / driver (pull_request) Successful in 5m49s
driver / publish (pull_request) Skipped
ping() returned three replies of 0 ms whenever the DAL accepted a PINGTEST request, without reading any result, so a LAN scan through this gateway marked every address alive. The DAL answer is only an acknowledgement with no reply count, so ping() now returns NAPALM's error reply without contacting the gateway and the driver opts out of ping sweeps with SUPPORTS_PING = False. Closes #2
508 lines
18 KiB
Python
508 lines
18 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",
|
|
"SerialNumber": "S220L12345678",
|
|
"HostName": "ZyxelVMG",
|
|
"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": "",
|
|
}
|
|
|
|
|
|
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 = 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 "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):
|
|
with patch("socket.create_connection") as mock_conn:
|
|
mock_conn.return_value.__enter__.return_value = MagicMock()
|
|
assert self.driver.is_alive()["is_alive"] is True
|
|
|
|
def test_is_alive_fail(self):
|
|
with patch("socket.create_connection") as mock_conn:
|
|
mock_conn.side_effect = OSError("refused")
|
|
assert self.driver.is_alive()["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"
|
|
|
|
def test_get_interfaces(self):
|
|
self._setup_mocked_http()
|
|
ifaces = self.driver.get_interfaces()
|
|
assert "wan" in ifaces
|
|
assert "lan" in ifaces
|
|
assert "wlan_2_4ghz" in ifaces
|
|
assert "wlan_5ghz" in ifaces
|
|
|
|
def test_get_interfaces_ip(self):
|
|
self._setup_mocked_http()
|
|
ips = self.driver.get_interfaces_ip()
|
|
assert "85.2.34.56" in ips["wan"]["ipv4"]
|
|
assert "192.168.1.1" in ips["lan"]["ipv4"]
|
|
|
|
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(self):
|
|
self._setup_mocked_http()
|
|
assert 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 = 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 = 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()
|