driver / standard (pull_request) Successful in 22s
driver / lint (pull_request) Successful in 16s
driver / types (pull_request) Successful in 1m3s
driver / test (3.12) (pull_request) Successful in 4m13s
driver / test (3.13) (pull_request) Successful in 4m5s
driver / lowest (pull_request) Successful in 3m38s
driver / build (pull_request) Successful in 30s
driver / security (pull_request) Successful in 1m19s
CI / driver (pull_request) Successful in 6m10s
driver / publish (pull_request) Skipped
get_interfaces_ip reported the speaker's address with a prefix length of 24 it never read: the speaker info has no netmask, and SoCo offers no reading for one, so a speaker in a /23 or /25 network was reported wrongly. cli answered [] -- not even NAPALM's dict shape -- for a speaker that has no CLI. Both overrides are gone; NAPALM's stubs raise NotImplementedError. Closes #15
407 lines
15 KiB
Python
407 lines
15 KiB
Python
from unittest.mock import MagicMock, PropertyMock, patch
|
|
|
|
import pytest
|
|
import requests
|
|
import soco
|
|
import soco.groups
|
|
from napalm.base import NetworkDriver
|
|
from napalm.base.exceptions import (
|
|
CommandErrorException,
|
|
ConnectionClosedException,
|
|
ConnectionException,
|
|
)
|
|
from soco.exceptions import SoCoUPnPException
|
|
|
|
from napalm_sonos import SonosDriver
|
|
|
|
|
|
def create_mock_speaker_info():
|
|
return {
|
|
"player_name": "Living Room",
|
|
"zone_name": "Living Room",
|
|
"uid": "RINCON_000E58ABCDE01400",
|
|
"model_name": "Sonos One",
|
|
"software_version": "15.2",
|
|
"hardware_version": "1.20.1",
|
|
"serial_number": "000E58ABCDE",
|
|
"mac_address": "00:0E:58:AB:CD:EF",
|
|
"ip_address": "192.168.1.100",
|
|
}
|
|
|
|
|
|
class TestSonosDriver:
|
|
def setup_method(self):
|
|
self.driver = SonosDriver("192.168.1.100")
|
|
# spec: a call to a method SoCo does not have fails instead of being invented (#9).
|
|
self.mock_device = MagicMock(spec=soco.SoCo)
|
|
self.mock_device.get_speaker_info.return_value = create_mock_speaker_info()
|
|
self.mock_device.volume = 30
|
|
self.mock_device.mute = False
|
|
self.mock_device.get_current_transport_info.return_value = {
|
|
"current_transport_state": "PLAYING",
|
|
"current_transport_status": "OK",
|
|
"current_transport_speed": "1",
|
|
}
|
|
self.mock_device.get_current_track_info.return_value = {
|
|
"title": "Test Song",
|
|
"artist": "Test Artist",
|
|
"album": "Test Album",
|
|
}
|
|
self.driver._device = self.mock_device
|
|
self.driver._speaker_info = create_mock_speaker_info()
|
|
|
|
def test_open_success(self):
|
|
driver = SonosDriver("192.168.1.100")
|
|
with patch("soco.SoCo") as mock_soco:
|
|
mock_instance = MagicMock()
|
|
mock_instance.get_speaker_info.return_value = create_mock_speaker_info()
|
|
mock_soco.return_value = mock_instance
|
|
driver.open()
|
|
assert driver._device is not None
|
|
assert driver._speaker_info is not None
|
|
assert driver._speaker_info["player_name"] == "Living Room"
|
|
|
|
def test_open_failure(self):
|
|
driver = SonosDriver("192.168.1.100")
|
|
with patch("soco.SoCo") as mock_soco:
|
|
mock_soco.side_effect = Exception("Connection refused")
|
|
try:
|
|
driver.open()
|
|
raise AssertionError("Expected ConnectionException")
|
|
except ConnectionException:
|
|
pass
|
|
|
|
def test_close(self):
|
|
self.driver.close()
|
|
assert self.driver._device is None
|
|
assert self.driver._speaker_info is None
|
|
|
|
def test_is_alive(self):
|
|
with patch("socket.create_connection") as mock_conn:
|
|
mock_conn.return_value.__enter__.return_value = MagicMock()
|
|
result = self.driver.is_alive()
|
|
assert result["is_alive"] is True
|
|
|
|
def test_is_alive_no_device(self):
|
|
self.driver._device = None
|
|
result = self.driver.is_alive()
|
|
assert result["is_alive"] is False
|
|
|
|
def test_get_facts(self):
|
|
facts = self.driver.get_facts()
|
|
assert facts["vendor"] == "Sonos"
|
|
assert facts["model"] == "Sonos One"
|
|
assert facts["serial_number"] == "000E58ABCDE"
|
|
assert facts["os_version"] == "15.2"
|
|
assert facts["hostname"] == "Living Room"
|
|
assert "wlan0" in facts["interface_list"]
|
|
|
|
def test_get_facts_empty(self):
|
|
self.driver._speaker_info = None
|
|
assert self.driver.get_facts() == {}
|
|
|
|
def test_get_interfaces(self):
|
|
with patch("socket.create_connection") as mock_conn:
|
|
mock_conn.return_value.__enter__.return_value = MagicMock()
|
|
ifaces = self.driver.get_interfaces()
|
|
assert "wlan0" in ifaces
|
|
assert ifaces["wlan0"]["is_up"] is True
|
|
assert ifaces["wlan0"]["mac_address"] == "00:0E:58:AB:CD:EF"
|
|
|
|
def test_a_speaker_reports_no_eth0(self):
|
|
"""SoCo has no reading that tells wired from wireless (#2): the driver no
|
|
longer guesses, not even from a dict-like WifiMode it used to look for."""
|
|
self.mock_device.device_properties = {"WifiMode": "0"}
|
|
|
|
with patch("socket.create_connection"):
|
|
interfaces = self.driver.get_interfaces()
|
|
assert "eth0" not in self.driver.get_facts()["interface_list"]
|
|
assert "eth0" not in interfaces
|
|
assert list(interfaces) == ["wlan0"]
|
|
|
|
def test_get_playback_state_has_the_contracts_shape(self):
|
|
"""``{"state", "source"}`` as napalm-device-types' MediaDriver declares it (#11)."""
|
|
self.mock_device.music_source = "RADIO"
|
|
|
|
assert self.driver.get_playback_state() == {"state": "playing", "source": "radio"}
|
|
|
|
@pytest.mark.parametrize(
|
|
("transport", "state"),
|
|
[
|
|
("PLAYING", "playing"),
|
|
("PAUSED_PLAYBACK", "paused"),
|
|
("STOPPED", "stopped"),
|
|
("TRANSITIONING", "transitioning"),
|
|
("NO_MEDIA_PRESENT", "stopped"),
|
|
],
|
|
)
|
|
def test_get_playback_state_reads_the_transport_state(self, transport, state):
|
|
"""SoCo has no get_playback_state(); the state is in the transport info (#9)."""
|
|
self.mock_device.music_source = "NONE"
|
|
self.mock_device.get_current_transport_info.return_value = {
|
|
"current_transport_state": transport,
|
|
"current_transport_status": "OK",
|
|
"current_transport_speed": "1",
|
|
}
|
|
assert self.driver.get_playback_state()["state"] == state
|
|
|
|
def test_a_transport_state_outside_the_contract_raises(self):
|
|
self.mock_device.music_source = "NONE"
|
|
self.mock_device.get_current_transport_info.return_value = {
|
|
"current_transport_state": "RECORDING"
|
|
}
|
|
with pytest.raises(CommandErrorException, match="RECORDING"):
|
|
self.driver.get_playback_state()
|
|
|
|
def test_get_volume(self):
|
|
vol = self.driver.get_volume()
|
|
assert vol == 30
|
|
|
|
def test_a_refused_upnp_read_raises(self):
|
|
"""A speaker that refuses the read is not a stopped one (#9)."""
|
|
self.mock_device.get_current_transport_info.side_effect = SoCoUPnPException(
|
|
"UPnP Error 701", "701", "<error/>"
|
|
)
|
|
with pytest.raises(CommandErrorException) as exc:
|
|
self.driver.get_playback_state()
|
|
assert isinstance(exc.value.__cause__, SoCoUPnPException)
|
|
|
|
def test_an_unreachable_speaker_raises_instead_of_reading_silent(self):
|
|
"""An unreachable speaker read as volume 0 and not muted (#9)."""
|
|
type(self.mock_device).volume = PropertyMock(
|
|
side_effect=requests.exceptions.ConnectTimeout("timed out")
|
|
)
|
|
with pytest.raises(ConnectionException) as exc:
|
|
self.driver.get_volume()
|
|
assert isinstance(exc.value.__cause__, requests.exceptions.ConnectTimeout)
|
|
|
|
def test_a_failed_mute_read_raises(self):
|
|
type(self.mock_device).mute = PropertyMock(
|
|
side_effect=requests.exceptions.ConnectionError("refused")
|
|
)
|
|
with pytest.raises(ConnectionException):
|
|
self.driver.get_mute()
|
|
|
|
def test_a_failed_track_read_raises(self):
|
|
self.mock_device.get_current_track_info.side_effect = requests.exceptions.ReadTimeout(
|
|
"timed out"
|
|
)
|
|
with pytest.raises(ConnectionException):
|
|
self.driver.get_current_track()
|
|
|
|
def test_set_volume(self):
|
|
self.driver.set_volume(50)
|
|
assert self.mock_device.volume == 50
|
|
|
|
def test_set_volume_clamped(self):
|
|
self.driver.set_volume(200)
|
|
assert self.mock_device.volume == 100
|
|
|
|
def test_get_mute(self):
|
|
assert self.driver.get_mute() is False
|
|
|
|
def test_set_mute(self):
|
|
self.driver.set_mute(True)
|
|
assert self.mock_device.mute is True
|
|
|
|
def test_play(self):
|
|
self.driver.play()
|
|
self.mock_device.play.assert_called_once()
|
|
|
|
def test_pause(self):
|
|
self.driver.pause()
|
|
self.mock_device.pause.assert_called_once()
|
|
|
|
def test_stop(self):
|
|
self.driver.stop()
|
|
self.mock_device.stop.assert_called_once()
|
|
|
|
def test_next_track(self):
|
|
self.driver.next_track()
|
|
self.mock_device.next.assert_called_once()
|
|
|
|
def test_previous_track(self):
|
|
self.driver.previous_track()
|
|
self.mock_device.previous.assert_called_once()
|
|
|
|
def test_get_current_track(self):
|
|
track = self.driver.get_current_track()
|
|
assert track["title"] == "Test Song"
|
|
assert track["artist"] == "Test Artist"
|
|
|
|
def _group(self, *others: tuple[str, str]) -> None:
|
|
"""This speaker ("Living Room") leads a group with *others* (name, uid)."""
|
|
self.mock_device.player_name = "Living Room"
|
|
self.mock_device.uid = "RINCON_000E58ABCDE01400"
|
|
self.mock_device.ip_address = "192.168.1.100"
|
|
members = [self.mock_device]
|
|
for name, uid in others:
|
|
member = MagicMock(spec=soco.SoCo)
|
|
member.player_name, member.uid, member.ip_address = name, uid, "192.168.1.101"
|
|
members.append(member)
|
|
group = MagicMock(spec=soco.groups.ZoneGroup)
|
|
group.coordinator = self.mock_device
|
|
group.members = set(members)
|
|
self.mock_device.group = group
|
|
|
|
def test_get_group_info(self):
|
|
self._group(("Kitchen", "RINCON_000E58ABCDE01401"))
|
|
|
|
group = self.driver.get_group_info()
|
|
assert group["coordinator"] == "Living Room"
|
|
assert len(group["members"]) == 2
|
|
|
|
def test_get_zone_info_has_the_contracts_shape(self):
|
|
"""A list of ``{"name", "coordinator", "members"}``, the others by name (#11)."""
|
|
self._group(("Kitchen", "RINCON_000E58ABCDE01401"))
|
|
|
|
assert self.driver.get_zone_info() == [
|
|
{"name": "Living Room", "coordinator": True, "members": ["Kitchen"]}
|
|
]
|
|
|
|
def test_a_member_is_no_coordinator(self):
|
|
self._group(("Kitchen", "RINCON_000E58ABCDE01401"))
|
|
kitchen = next(m for m in self.mock_device.group.members if m is not self.mock_device)
|
|
self.mock_device.group.coordinator = kitchen
|
|
|
|
zone = self.driver.get_zone_info()[0]
|
|
assert (zone["coordinator"], zone["members"]) == (False, ["Kitchen"])
|
|
|
|
def test_a_speaker_alone_is_a_zone_without_other_members(self):
|
|
self._group()
|
|
|
|
assert self.driver.get_zone_info() == [
|
|
{"name": "Living Room", "coordinator": True, "members": []}
|
|
]
|
|
|
|
def test_a_speaker_in_no_group_has_neither(self):
|
|
self.mock_device.group = None
|
|
|
|
assert (self.driver.get_zone_info(), self.driver.get_group_info()) == ([], {})
|
|
|
|
@pytest.mark.parametrize("getter", ["get_zone_info", "get_group_info"])
|
|
def test_a_failed_group_read_raises(self, getter):
|
|
"""It read as "no group" / "no zone" (#11)."""
|
|
type(self.mock_device).group = PropertyMock(
|
|
side_effect=requests.exceptions.ConnectTimeout("timed out")
|
|
)
|
|
with pytest.raises(ConnectionException):
|
|
getattr(self.driver, getter)()
|
|
|
|
def test_the_media_controls_are_methods_not_a_string_dispatch(self):
|
|
"""run_device_action returned another shape than its contract and is gone;
|
|
play(), set_volume() and the others are called directly (netOrk #1105)."""
|
|
assert not hasattr(type(self.driver), "run_device_action")
|
|
self.driver.play()
|
|
self.driver.set_volume(42)
|
|
self.mock_device.play.assert_called_once()
|
|
assert self.mock_device.volume == 42
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"getter",
|
|
[
|
|
lambda d: d.get_volume(),
|
|
lambda d: d.get_mute(),
|
|
lambda d: d.get_playback_state(),
|
|
lambda d: d.get_current_track(),
|
|
lambda d: d.get_group_info(),
|
|
lambda d: d.get_zone_info(),
|
|
],
|
|
ids=[
|
|
"get_volume",
|
|
"get_mute",
|
|
"get_playback_state",
|
|
"get_current_track",
|
|
"get_group_info",
|
|
"get_zone_info",
|
|
],
|
|
)
|
|
def test_a_getter_refuses_when_not_connected(getter):
|
|
"""A default (0, False, "STOPPED", {}) made a driver never opened read as a quiet speaker."""
|
|
with pytest.raises(ConnectionClosedException):
|
|
getter(SonosDriver("192.168.1.100"))
|
|
|
|
|
|
def test_the_driver_module_has_its_docstring():
|
|
import napalm_sonos.sonos_driver as module
|
|
|
|
assert module.__doc__ and "Sonos" in module.__doc__
|
|
|
|
|
|
#: NAPALM getters a speaker has nothing for. Each stays NAPALM's own stub, which raises
|
|
#: NotImplementedError: an override answering {} or [] reads as "implemented, nothing
|
|
#: there" to a caller that asks whether the driver has its own getter (#13).
|
|
_NOT_SUPPORTED_GETTERS = [
|
|
"get_arp_table",
|
|
"get_bgp_config",
|
|
"get_bgp_neighbors",
|
|
"get_bgp_neighbors_detail",
|
|
"get_config",
|
|
"get_environment",
|
|
"get_firewall_policies",
|
|
# The speaker reports no prefix length; it was always given as 24 (#15).
|
|
"get_interfaces_ip",
|
|
"get_lldp_neighbors",
|
|
"get_lldp_neighbors_detail",
|
|
"get_mac_address_table",
|
|
"get_network_instances",
|
|
"get_ntp_peers",
|
|
"get_ntp_servers",
|
|
"get_ntp_stats",
|
|
"get_optics",
|
|
"get_probes_config",
|
|
"get_probes_results",
|
|
"get_route_to",
|
|
"get_snmp_information",
|
|
"get_users",
|
|
]
|
|
|
|
|
|
@pytest.mark.parametrize("getter", _NOT_SUPPORTED_GETTERS)
|
|
def test_an_unsupported_getter_is_napalms_stub(getter):
|
|
assert getattr(SonosDriver, getter) is getattr(NetworkDriver, getter)
|
|
|
|
|
|
def test_cli_is_napalms_stub():
|
|
"""A speaker has no CLI; `[]` was not even NAPALM's dict shape (#15)."""
|
|
assert SonosDriver.cli is NetworkDriver.cli
|
|
with pytest.raises(NotImplementedError):
|
|
SonosDriver("192.0.2.20").cli(["show version"])
|
|
|
|
|
|
def test_get_interfaces_ip_says_not_implemented():
|
|
with pytest.raises(NotImplementedError):
|
|
SonosDriver("192.0.2.20").get_interfaces_ip()
|
|
|
|
|
|
def test_get_config_with_napalms_arguments_says_not_implemented():
|
|
"""`get_config(retrieve="running")` raised TypeError, read as a failed backup (#13)."""
|
|
with pytest.raises(NotImplementedError):
|
|
SonosDriver("192.0.2.20").get_config(retrieve="running")
|
|
|
|
|
|
def test_get_route_to_with_napalms_defaults_says_not_implemented():
|
|
"""The override required `destination`; NAPALM's getter defaults it (#13)."""
|
|
with pytest.raises(NotImplementedError):
|
|
SonosDriver("192.0.2.20").get_route_to()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"control",
|
|
[
|
|
lambda d: d.play(),
|
|
lambda d: d.pause(),
|
|
lambda d: d.stop(),
|
|
lambda d: d.next_track(),
|
|
lambda d: d.previous_track(),
|
|
lambda d: d.set_volume(10),
|
|
lambda d: d.set_mute(True),
|
|
],
|
|
ids=["play", "pause", "stop", "next_track", "previous_track", "set_volume", "set_mute"],
|
|
)
|
|
def test_a_media_control_refuses_when_not_connected(control):
|
|
"""Returning silently made a control that did nothing look like it had worked."""
|
|
with pytest.raises(ConnectionClosedException):
|
|
control(SonosDriver("192.168.1.100"))
|