The wired check read device_properties, which SoCo does not have (deviceProperties is the UPnP service, and none of its actions says wired or wireless), and swallowed the AttributeError, so eth0 was never reported and the guess served nothing. It is gone: a speaker reports its one connection as wlan0, described as of unknown medium, and the README and the getter docstrings say that wired vs. wireless is not known. Closes #2
293 lines
11 KiB
Python
293 lines
11 KiB
Python
from unittest.mock import MagicMock, PropertyMock, patch
|
|
|
|
import pytest
|
|
import requests
|
|
import soco
|
|
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 "eth0" not in self.driver.get_interfaces_ip()
|
|
assert list(interfaces) == ["wlan0"]
|
|
|
|
def test_get_interfaces_ip(self):
|
|
ifaces_ip = self.driver.get_interfaces_ip()
|
|
assert "wlan0" in ifaces_ip
|
|
assert "192.168.1.100" in ifaces_ip["wlan0"]["ipv4"]
|
|
|
|
def test_get_playback_state(self):
|
|
state = self.driver.get_playback_state()
|
|
assert state == "PLAYING"
|
|
|
|
def test_get_playback_state_reads_the_transport_state(self):
|
|
"""SoCo has no get_playback_state(); the state is in the transport info (#9)."""
|
|
self.mock_device.get_current_transport_info.return_value = {
|
|
"current_transport_state": "PAUSED_PLAYBACK",
|
|
"current_transport_status": "OK",
|
|
"current_transport_speed": "1",
|
|
}
|
|
assert self.driver.get_playback_state() == "PAUSED_PLAYBACK"
|
|
|
|
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 test_get_group_info(self):
|
|
mock_coordinator = MagicMock()
|
|
mock_coordinator.player_name = "Living Room"
|
|
mock_coordinator.uid = "RINCON_000E58ABCDE01400"
|
|
|
|
mock_member = MagicMock()
|
|
mock_member.player_name = "Kitchen"
|
|
mock_member.uid = "RINCON_000E58ABCDE01401"
|
|
mock_member.ip_address = "192.168.1.101"
|
|
|
|
mock_group = MagicMock()
|
|
mock_group.coordinator = mock_coordinator
|
|
mock_group.members = [mock_coordinator, mock_member]
|
|
self.mock_device.group = mock_group
|
|
|
|
group = self.driver.get_group_info()
|
|
assert group["coordinator"] == "Living Room"
|
|
assert len(group["members"]) == 2
|
|
|
|
def test_get_zone_info(self):
|
|
zone = self.driver.get_zone_info()
|
|
assert zone["player_name"] == "Living Room"
|
|
assert zone["model_name"] == "Sonos One"
|
|
assert zone["ip_address"] == "192.168.1.100"
|
|
|
|
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(),
|
|
],
|
|
ids=["get_volume", "get_mute", "get_playback_state", "get_current_track"],
|
|
)
|
|
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__
|
|
|
|
|
|
def test_get_arp_table_takes_napalms_vrf_argument():
|
|
assert SonosDriver("192.168.1.100").get_arp_table(vrf="") == []
|
|
|
|
|
|
@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"))
|