Files
napalm-sonos/tests/test_sonos.py
T
Christian Manivong 53ea5f051f fix(driver): stop guessing whether a speaker is wired
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
2026-11-02 09:26:58 +01:00

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"))