mirror of
https://github.com/firestar5683/StarPilot.git
synced 2026-11-08 05:23:41 +08:00
Prabhaav Pillai
465 lines
21 KiB
Python
465 lines
21 KiB
Python
import os
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from openpilot.starpilot.soloist import backend, client, credentials, preferences, supervisor
|
|
from openpilot.starpilot.soloist.paths import Layout
|
|
|
|
|
|
@pytest.fixture
|
|
def layout(tmp_path):
|
|
return Layout(tmp_path / 'soloist')
|
|
|
|
|
|
def test_credentials_are_private_and_never_echoed(layout):
|
|
assert not credentials.present(layout)
|
|
with pytest.raises(credentials.InvalidKey):
|
|
credentials.store('short', layout)
|
|
with pytest.raises(credentials.InvalidKey):
|
|
credentials.store('abc def ghi jkl mno pqr', layout)
|
|
credentials.store(' sk_live_0123456789abcdef ', layout)
|
|
assert credentials.load(layout) == 'sk_live_0123456789abcdef'
|
|
assert layout.api_key.stat().st_mode & 0o777 == 0o600
|
|
assert layout.api_key.parent.stat().st_mode & 0o777 == 0o700
|
|
credentials.remove(layout)
|
|
assert not credentials.present(layout)
|
|
|
|
|
|
def test_preferences_validate_and_round_trip(layout):
|
|
assert preferences.load(layout) == preferences.Preferences()
|
|
saved = preferences.save(preferences.Preferences(device_name=' Civic ', output_address='aa:bb:cc:dd:ee:ff', output_name='Car'), layout)
|
|
assert saved.device_name == 'Civic' and saved.output_address == 'AA:BB:CC:DD:EE:FF'
|
|
assert preferences.load(layout) == saved
|
|
assert preferences.validated({**preferences.Preferences().__dict__, 'output': 'starport'}).output == 'starport'
|
|
for bad in ({'device_name': ''}, {'cache_mb': 50}, {'initial_volume': 101}, {'output': 'speaker'}, {'output_address': 'nope'}):
|
|
with pytest.raises(ValueError):
|
|
preferences.validated({**preferences.Preferences().__dict__, **bad})
|
|
layout.config.write_text('{"device_name": 7}')
|
|
assert preferences.load(layout) == preferences.Preferences()
|
|
|
|
|
|
def test_enabled_flag(layout):
|
|
from openpilot.starpilot.soloist.paths import enabled
|
|
assert not enabled(layout)
|
|
preferences.set_enabled(True, layout)
|
|
assert enabled(layout)
|
|
preferences.set_enabled(False, layout)
|
|
assert not enabled(layout)
|
|
|
|
|
|
def test_alsa_config_is_process_local_bluealsa_pcm():
|
|
text = backend.alsa_config('AA:BB:CC:DD:EE:FF', Path('/usr/share/alsa/alsa.conf'))
|
|
assert text.startswith('</usr/share/alsa/alsa.conf>')
|
|
assert 'type bluealsa' in text and 'device "AA:BB:CC:DD:EE:FF"' in text and 'profile "a2dp"' in text
|
|
with pytest.raises(backend.BackendUnavailable):
|
|
backend.alsa_config('AA:BB:CC:DD:EE:FF"\n}', Path('/usr/share/alsa/alsa.conf'))
|
|
|
|
|
|
def test_launch_commands_isolate_the_server_and_player(layout):
|
|
prefs = preferences.Preferences(output_address='AA:BB:CC:DD:EE:FF', initial_volume=60)
|
|
server = backend.server_launch(layout, prefs, alsa_base=Path('/usr/share/alsa/alsa.conf'))
|
|
assert '-n' in server.argv and '--system=no' in server.argv
|
|
assert any(arg.startswith('module-alsa-sink device=starpilot_spotify') for arg in server.argv)
|
|
assert server.env['ALSA_CONFIG_PATH'].startswith(str(layout.runtime))
|
|
assert (layout.runtime / 'alsa.conf').stat().st_mode & 0o777 == 0o600
|
|
test = backend.server_launch(layout, preferences.Preferences(output='test'))
|
|
assert any(arg.startswith('module-null-sink') for arg in test.argv) and 'ALSA_CONFIG_PATH' not in test.env
|
|
silent = backend.server_launch(layout, prefs, silent=True, alsa_base=Path('/usr/share/alsa/alsa.conf'))
|
|
assert 'module-null-sink sink_name=spotify_silent' in silent.argv and 'ALSA_CONFIG_PATH' in silent.env
|
|
player = backend.player_launch(layout, prefs, 'sk_live_0123456789abcdef')
|
|
assert 'PULSE_SINK' not in player.env # follows the server's default sink, so outputs can switch live
|
|
assert player.argv[player.argv.index('--ws') + 1] == '127.0.0.1:0'
|
|
assert player.argv[player.argv.index('--cache-size') + 1] == '256'
|
|
assert player.argv[player.argv.index('--initial-volume') + 1] == '60'
|
|
assert player.env['PULSE_SERVER'] == f'unix:{layout.runtime}/pulse/native'
|
|
|
|
|
|
def test_vendored_server_matches_its_checksums():
|
|
import hashlib
|
|
root = backend.SERVER_ROOT
|
|
assert backend.bundle_ready()
|
|
sums = [line.split() for line in (root / 'SHA256SUMS').read_text().splitlines() if line.strip()]
|
|
assert {name for _, name in sums} >= {'bin/pulseaudio', 'lib/libpulsecore-16.1.so', 'modules/module-pipe-sink.so'}
|
|
for digest, name in sums:
|
|
assert hashlib.sha256((root / name).read_bytes()).hexdigest() == digest, name
|
|
for name in ('pulseaudio', 'libltdl7', 'liborc-0.4-0t64', 'libsoxr0', 'libspeexdsp1', 'libtdb1'):
|
|
assert (root / 'licenses' / f'{name}.copyright').is_file()
|
|
|
|
|
|
def test_starport_output_is_a_real_time_pipe(layout):
|
|
launch = backend.server_launch(layout, preferences.Preferences(output='starport'))
|
|
sink = next(arg for arg in launch.argv if arg.startswith('module-pipe-sink'))
|
|
assert f'file={backend.starport_pipe(layout)}' in sink
|
|
assert 'rate=48000' in sink and 'channels=2' in sink and 'use_system_clock_for_timing=yes' in sink
|
|
assert launch.env['LD_LIBRARY_PATH'] == str(backend.SERVER_ROOT / 'lib')
|
|
|
|
|
|
ENTITY = {'uri': 'spotify:track:1', 'entity_type': 'track', 'decorations': {
|
|
'identity': {'name': 'My Song\x07'}, 'visual_identity': {'cover': [{'url': 'http://i.scdn.co/a', 'size': 'default'},
|
|
{'url': 'https://i.scdn.co/image/x', 'size': 'large'},
|
|
{'url': 'https://evil.example/x', 'size': 'default'}]},
|
|
'parent': {'entity': {'decorations': {'identity': {'name': 'Album'}}}},
|
|
'creators': [{'entity': {'decorations': {'identity': {'name': 'A'}}}}, {'entity': {'decorations': {'identity': {'name': 'B'}}}}],
|
|
'playback': {'duration_ms': 210000}}}
|
|
|
|
|
|
def test_player_state_normalizes_untrusted_events():
|
|
state = client.PlayerState()
|
|
state.apply({'type': 'auth_state', 'logged_in': True, 'is_active': False, 'device_name': 'StarPilot'})
|
|
state.apply({'type': 'playback_state', 'status': 'playing', 'item': ENTITY, 'volume': 65, 'is_active': True,
|
|
'position': {'position_ms': 45000, 'timestamp_ms': 1747654321000, 'speed': 1.0},
|
|
'options': {'shuffle': True, 'repeat': 'context'},
|
|
'available_actions': {'pause': {}, 'skip_next': {}, 'seek_forward': {'step_ms': 15000}, 'bogus': {}}})
|
|
value = state.value
|
|
assert value['track'] == {'title': 'My Song', 'artists': 'A, B', 'album': 'Album', 'artwork': 'https://i.scdn.co/image/x',
|
|
'kind': 'track', 'durationMs': 210000}
|
|
assert value['actions'] == ['pause', 'skip_next'] and value['shuffle'] and value['repeat'] == 'context'
|
|
state.apply({'type': 'volume_changed', 'volume': 900})
|
|
assert value['volume'] == 65
|
|
state.apply({'type': 'playback_changed', 'status': 'paused'})
|
|
assert value['status'] == 'paused'
|
|
state.apply({'type': 'auth_state', 'logged_in': False})
|
|
assert value['track'] is None and value['actions'] == []
|
|
|
|
|
|
def test_controls_map_to_documented_commands():
|
|
assert client.commands('next', {}) == [{'type': 'command', 'command': 'skip_next'}]
|
|
assert client.commands('volume', {'volume': 40}) == [{'type': 'command', 'command': 'set_volume', 'volume': 40}]
|
|
assert [c['command'] for c in client.commands('repeat', {'mode': 'track'})] == ['set_repeat_context', 'set_repeat_track']
|
|
assert [(c['command'], c['enabled']) for c in client.commands('repeat', {'mode': 'off'})] == \
|
|
[('set_repeat_track', False), ('set_repeat_context', False)]
|
|
for action, args in (('volume', {'volume': 101}), ('seek', {'positionMs': -1}), ('play', {'uri': 'x'}), ('shell', {}),
|
|
('shuffle', {'enabled': 1})):
|
|
with pytest.raises(ValueError):
|
|
client.commands(action, args)
|
|
|
|
|
|
def test_endpoint_only_accepts_loopback(tmp_path):
|
|
assert client.endpoint(tmp_path) is None
|
|
(tmp_path / 'ws.addr').write_text('127.0.0.1\n')
|
|
(tmp_path / 'ws.port').write_text('41103\n')
|
|
assert client.endpoint(tmp_path) == 'ws://127.0.0.1:41103'
|
|
(tmp_path / 'ws.addr').write_text('0.0.0.0')
|
|
assert client.endpoint(tmp_path) is None
|
|
|
|
|
|
class FakeProcess:
|
|
def __init__(self, argv, **kwargs):
|
|
import io
|
|
self.argv, self.kwargs = argv, kwargs
|
|
self.pid = 99999999
|
|
self.code = None
|
|
self.stdout = io.BytesIO(b'I client expires in 42 days\nkey ' + b'sk_live_0123456789abcdef\n' if 'soloist' in argv[0] else b'')
|
|
def poll(self): return self.code
|
|
def wait(self, timeout=None): return self.code
|
|
|
|
|
|
class FakeClient:
|
|
logged_in = True
|
|
def __init__(self, _data):
|
|
self.on_change = lambda: None
|
|
self.started = self.stopped = False
|
|
self.sent = []
|
|
def start(self): self.started = True
|
|
def stop(self): self.stopped = True
|
|
def snapshot(self): return {'connected': True, 'loggedIn': self.logged_in, 'status': 'idle', 'active': False}
|
|
def send(self, action, args): self.sent.append((action, args))
|
|
|
|
|
|
def ready_layout(layout, monkeypatch, *, expired=False):
|
|
monkeypatch.setattr(supervisor.phone_audio, 'profile', lambda action: None)
|
|
monkeypatch.setattr(supervisor.package, 'release_status', lambda _l: {'installed': True, 'expired': expired})
|
|
monkeypatch.setattr(supervisor.backend, 'bundle_ready', lambda: True)
|
|
layout.root.mkdir(parents=True, exist_ok=True)
|
|
credentials.store('sk_live_0123456789abcdef', layout)
|
|
preferences.save(preferences.Preferences(output='test'), layout)
|
|
|
|
|
|
def make_supervisor(layout, spawned, logged_in=True):
|
|
def spawn(argv, **kwargs):
|
|
process = FakeProcess(argv, **kwargs)
|
|
spawned.append(process)
|
|
if 'pulseaudio' in argv[0]:
|
|
backend.runtime_paths(layout)['socket'].touch()
|
|
return process
|
|
now = [100.0]
|
|
make_client = type('Client', (FakeClient,), {'logged_in': logged_in})
|
|
sup = supervisor.Supervisor(layout, spawn=spawn, clock=lambda: now[0], make_client=make_client, network=lambda: True) # ty: ignore[invalid-argument-type]
|
|
sup.run_async = lambda fn: fn()
|
|
return sup, now
|
|
|
|
|
|
def test_supervisor_reports_missing_setup_steps(layout, monkeypatch):
|
|
sup, _ = make_supervisor(layout, [])
|
|
sup.tick()
|
|
assert sup.status()['state'] == 'missing_package'
|
|
monkeypatch.setattr(supervisor.package, 'release_status', lambda _l: {'installed': True})
|
|
sup.tick()
|
|
assert sup.status()['state'] == 'missing_key'
|
|
credentials.store('sk_live_0123456789abcdef', layout)
|
|
sup.tick()
|
|
assert sup.status()['state'] == 'no_output'
|
|
|
|
|
|
def test_supervisor_starts_server_then_player_and_redacts_key(layout, monkeypatch):
|
|
ready_layout(layout, monkeypatch)
|
|
spawned = []
|
|
sup, _ = make_supervisor(layout, spawned, logged_in=False)
|
|
sup.tick()
|
|
assert [Path(p.argv[0]).name for p in spawned] == ['pulseaudio', 'soloist']
|
|
assert all(p.kwargs['start_new_session'] for p in spawned)
|
|
assert sup.status()['state'] == 'waiting'
|
|
import time
|
|
time.sleep(0.1)
|
|
assert sup.days_left == 42
|
|
assert all('sk_live' not in line for line in sup.log)
|
|
assert sup.handle({'command': 'control', 'action': 'pause', 'args': {}}) == {'ok': True}
|
|
assert sup.client.sent == [('pause', {})]
|
|
assert sup.handle({'command': 'control', 'action': 'play_pause', 'args': {}}) == {'ok': True}
|
|
assert sup.client.sent[-1] == ('play', {})
|
|
sup.client.snapshot = lambda: {'status': 'playing'}
|
|
sup.handle({'command': 'control', 'action': 'play_pause', 'args': {}})
|
|
assert sup.client.sent[-1] == ('pause', {})
|
|
|
|
|
|
def test_supervisor_stops_retrying_an_expired_build(layout, monkeypatch):
|
|
ready_layout(layout, monkeypatch)
|
|
spawned = []
|
|
sup, now = make_supervisor(layout, spawned)
|
|
monkeypatch.setattr(supervisor, '_kill_group', lambda _p: None)
|
|
sup.tick()
|
|
sup.player.code = 10
|
|
now[0] += 1
|
|
sup.tick()
|
|
assert sup.status()['state'] == 'expired'
|
|
now[0] += 1000
|
|
sup.tick()
|
|
assert len(spawned) == 2
|
|
|
|
|
|
def test_supervisor_backs_off_and_rolls_back_a_failing_build(layout, monkeypatch):
|
|
ready_layout(layout, monkeypatch)
|
|
rolled = []
|
|
monkeypatch.setattr(supervisor.package, 'rollback', lambda _l: rolled.append(True) or True)
|
|
monkeypatch.setattr(supervisor, '_kill_group', lambda _p: None)
|
|
spawned = []
|
|
sup, now = make_supervisor(layout, spawned)
|
|
for _ in range(supervisor.MAX_FAST_FAILURES):
|
|
sup.tick()
|
|
sup.player.code = 1
|
|
now[0] += 1
|
|
sup.tick()
|
|
assert sup.status()['state'] == 'retrying'
|
|
now[0] += 100
|
|
assert rolled == [True]
|
|
|
|
|
|
def _speaker_supervisor(layout, monkeypatch, *, can_switch):
|
|
ready_layout(layout, monkeypatch)
|
|
preferences.save(preferences.Preferences(output_address='AA:BB:CC:DD:EE:FF', output_name='Car'), layout)
|
|
class Output:
|
|
connected = False
|
|
def ready(self, address):
|
|
return self.connected
|
|
switched = []
|
|
monkeypatch.setattr(supervisor.backend, 'can_switch', lambda: can_switch)
|
|
monkeypatch.setattr(supervisor.backend, 'switch_output', lambda _layout, speaker: switched.append(speaker))
|
|
monkeypatch.setattr(supervisor, '_kill_group', lambda _p: None)
|
|
spawned = []
|
|
sup, now = make_supervisor(layout, spawned)
|
|
sup.output = Output()
|
|
sup.tick()
|
|
assert sup.status()['state'] == 'ready' and sup.status()['outputWaiting'] == 'Car'
|
|
assert len(spawned) == 2 and sup.client.started
|
|
assert 'module-null-sink sink_name=spotify_silent' in spawned[0].argv
|
|
sup.output.connected = True
|
|
for _ in range(2): # one check is not enough; the speaker has to stay connected
|
|
now[0] += supervisor.OUTPUT_RETRY_SECONDS + 1
|
|
sup.tick()
|
|
assert len(spawned) == 2 and switched == []
|
|
sup.tick()
|
|
return sup, now, spawned, switched
|
|
|
|
|
|
def test_speaker_returning_switches_audio_without_restarting_soloist(layout, monkeypatch):
|
|
sup, now, spawned, switched = _speaker_supervisor(layout, monkeypatch, can_switch=True)
|
|
client = sup.client
|
|
assert switched == [True] and len(spawned) == 2 and sup.client is client and not client.stopped
|
|
assert sup.status()['outputWaiting'] == ''
|
|
sup.output.connected = False
|
|
for _ in range(3):
|
|
now[0] += supervisor.OUTPUT_RETRY_SECONDS + 1
|
|
sup.tick()
|
|
assert switched == [True, False] and len(spawned) == 2
|
|
assert sup.status()['outputWaiting'] == 'Car'
|
|
|
|
|
|
def test_speaker_switch_falls_back_to_a_restart(layout, monkeypatch):
|
|
sup, _now, spawned, switched = _speaker_supervisor(layout, monkeypatch, can_switch=False)
|
|
(layout.state / 'saved-session').write_text('retained')
|
|
sup.tick()
|
|
assert switched == [] and len(spawned) == 4
|
|
assert any(arg.startswith('module-alsa-sink') for arg in spawned[2].argv)
|
|
assert (layout.state / 'saved-session').read_text() == 'retained'
|
|
assert sup.status()['outputWaiting'] == ''
|
|
|
|
|
|
def test_switch_output_moves_streams_and_drops_the_old_sink(layout):
|
|
calls = []
|
|
outputs = {('list', 'short', 'sink-inputs'): '7\t1\t3\tprotocol-native.c\ts16le 2ch 44100Hz\n',
|
|
('list', 'short', 'modules'): ('0\tmodule-native-protocol-unix\tsocket=/x\n' +
|
|
'1\tmodule-null-sink\tsink_name=spotify_silent\n' +
|
|
'2\tmodule-alsa-sink\tdevice=starpilot_spotify sink_name=spotify channels=2 tsched=0\n')}
|
|
def run(argv, **kwargs):
|
|
calls.append(tuple(argv[1:]))
|
|
assert kwargs['env']['PULSE_SERVER'].startswith('unix:') and kwargs['timeout'] and kwargs['check']
|
|
return subprocess.CompletedProcess(argv, 0, outputs.get(tuple(argv[1:]), ''))
|
|
backend.switch_output(layout, True, run=run)
|
|
assert calls == [('load-module', 'module-alsa-sink', 'device=starpilot_spotify', 'sink_name=spotify', 'channels=2', 'tsched=0'),
|
|
('set-default-sink', 'spotify'), ('list', 'short', 'sink-inputs'), ('move-sink-input', '7', 'spotify'),
|
|
('list', 'short', 'modules'), ('unload-module', '1')]
|
|
calls.clear()
|
|
backend.switch_output(layout, False, run=run)
|
|
assert calls[0] == ('load-module', 'module-null-sink', 'sink_name=spotify_silent') and calls[-1] == ('unload-module', '2')
|
|
|
|
def test_control_socket_round_trip(layout, tmp_path):
|
|
import threading
|
|
from openpilot.starpilot.galaxy.spotify_setup import SpotifyClient
|
|
sup, _ = make_supervisor(layout, [])
|
|
import tempfile
|
|
folder = tempfile.mkdtemp(prefix='sp-', dir='/tmp') # AF_UNIX paths are short on macOS
|
|
path = folder + '/s.sock'
|
|
stop = threading.Event()
|
|
thread = threading.Thread(target=supervisor.serve, args=(sup, path, stop), daemon=True)
|
|
thread.start()
|
|
try:
|
|
import time
|
|
client = SpotifyClient(path)
|
|
result = None
|
|
for attempt in range(50):
|
|
if not Path(path).exists():
|
|
time.sleep(0.02)
|
|
continue
|
|
try:
|
|
result = client.call('status')
|
|
break
|
|
except (FileNotFoundError, ConnectionRefusedError):
|
|
if attempt == 49:
|
|
raise
|
|
time.sleep(0.02)
|
|
assert result is not None
|
|
assert result['status']['state'] == 'starting'
|
|
with pytest.raises(RuntimeError):
|
|
client.call('control', action='pause', args={})
|
|
finally:
|
|
stop.set()
|
|
thread.join(timeout=2)
|
|
Path(path).unlink(missing_ok=True)
|
|
os.rmdir(folder)
|
|
assert not thread.is_alive()
|
|
|
|
|
|
|
|
def test_reap_orphans_only_targets_feature_binaries(layout, tmp_path, monkeypatch):
|
|
proc = tmp_path / 'proc'
|
|
(proc / '100').mkdir(parents=True)
|
|
(proc / '200').mkdir()
|
|
binary = layout.root / 'releases' / 'x' / 'soloist'
|
|
binary.parent.mkdir(parents=True)
|
|
binary.write_text('')
|
|
(proc / '100' / 'exe').symlink_to(binary)
|
|
(proc / '200' / 'exe').symlink_to('/usr/bin/bluealsa')
|
|
killed = []
|
|
monkeypatch.setattr(supervisor.os, 'kill', lambda pid, sig: killed.append(pid))
|
|
assert supervisor.reap_orphans(layout, proc) == 1 and killed == [100]
|
|
|
|
|
|
def test_status_publishes_the_spotify_track_for_the_car_screen(layout):
|
|
sup, _ = make_supervisor(layout, [])
|
|
sup.client = type('Client', (), {'snapshot': lambda self: {
|
|
'connected': True, 'loggedIn': True, 'active': True, 'status': 'playing', 'position': None,
|
|
'track': {'title': 'Song', 'artists': 'Band', 'album': '', 'durationMs': 1000}}})()
|
|
assert sup.status()['nowPlaying']['title'] == 'Song'
|
|
sup.client = None
|
|
assert sup.status()['nowPlaying'] is None
|
|
|
|
|
|
def test_status_publishes_the_phone_track_only_while_phone_audio_runs(layout):
|
|
sup, _ = make_supervisor(layout, [])
|
|
sup.phone_prefs = object()
|
|
sup.phone_track = {'Status': 'playing', 'Track': {'Title': 'Phone Song', 'Artist': 'Band'}}
|
|
assert sup.status()['nowPlaying'] is None
|
|
sup.player = object()
|
|
found = sup.status()['nowPlaying']
|
|
assert found['source'] == 'phone' and found['title'] == 'Phone Song'
|
|
|
|
|
|
def test_supervisor_waits_for_network_before_starting(layout, monkeypatch):
|
|
ready_layout(layout, monkeypatch)
|
|
spawned = []
|
|
sup, _ = make_supervisor(layout, spawned)
|
|
up = [False]
|
|
sup.network = lambda: up[0]
|
|
sup.tick()
|
|
assert spawned == []
|
|
assert sup.status()['state'] == 'waiting_network'
|
|
assert sup.fast_failures == 0
|
|
up[0] = True
|
|
sup.tick()
|
|
assert [Path(p.argv[0]).name for p in spawned] == ['pulseaudio', 'soloist']
|
|
|
|
|
|
def test_changing_mute_values_never_restarts_the_player(layout, monkeypatch):
|
|
from dataclasses import replace
|
|
ready_layout(layout, monkeypatch)
|
|
spawned = []
|
|
sup, now = make_supervisor(layout, spawned)
|
|
sup.tick()
|
|
assert len(spawned) == 2
|
|
preferences.save(replace(preferences.load(layout), pause_mute=1.2, skip_mute=0.0), layout)
|
|
assert preferences.load(layout).pause_mute == 1.2
|
|
now[0] += 1
|
|
sup.tick()
|
|
assert len(spawned) == 2 and not sup.client.stopped and all(p.poll() is None for p in spawned)
|
|
preferences.save(replace(preferences.load(layout), cache_mb=512), layout) # a real change still restarts
|
|
sup.tick()
|
|
assert len(spawned) == 4
|
|
|
|
|
|
def test_changing_mute_values_keeps_phone_audio_running(layout, monkeypatch):
|
|
from dataclasses import replace
|
|
ready_layout(layout, monkeypatch)
|
|
preferences.save(preferences.Preferences(output='test', source='phone', phone_address='AA:BB:CC:DD:EE:FF'), layout)
|
|
spawned = []
|
|
sup, now = make_supervisor(layout, spawned)
|
|
sup.phone.powered = lambda: True
|
|
sup.phone.ready = lambda *_a: True
|
|
sup.phone.track = lambda _a: None
|
|
monkeypatch.setattr(supervisor.phone_audio, 'profile', lambda *_a: None)
|
|
sup.tick()
|
|
assert [Path(p.argv[0]).name for p in spawned][0] == 'pulseaudio' and len(spawned) == 2
|
|
preferences.save(replace(preferences.load(layout), pause_mute=1.5, skip_mute=0.05), layout)
|
|
now[0] += 1
|
|
sup.tick()
|
|
assert len(spawned) == 2 and all(p.poll() is None for p in spawned)
|
|
preferences.save(replace(preferences.load(layout), cache_mb=512), layout)
|
|
sup.tick()
|
|
assert len(spawned) == 4
|
|
|
|
|
|
@pytest.mark.parametrize(('ipv4', 'ipv6', 'expected'), [
|
|
('', '', False),
|
|
('Iface Destination Gateway Flags', '', False),
|
|
('wlan0 00000000 0100000A 0003', '', True),
|
|
('', '0' * 32 + ' 00 ' + '0' * 32 + ' 00 ' + '0' * 32 + ' 00000001 00000000 00000000 00000003 wlan0', True),
|
|
('', '0' * 32 + ' 00 ' + '0' * 32 + ' 00 ' + '0' * 32 + ' 00000001 00000000 00000000 00200200 lo', False),
|
|
('wlan0 00000000 0100000A 0201', '', False),
|
|
('lo 00000000 00000000 0001', '', False),
|
|
])
|
|
def test_network_ready_accepts_either_address_family(monkeypatch, ipv4, ipv6, expected):
|
|
from io import StringIO
|
|
monkeypatch.setattr('builtins.open', lambda path: StringIO(ipv4 if path.endswith('/route') else ipv6))
|
|
assert supervisor.network_ready() is expected
|