1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
"""Tests for idasen_ha."""
import asyncio
from unittest import mock
from unittest.mock import MagicMock, Mock
from bleak.backends.device import BLEDevice
from bleak.exc import BleakDBusError, BleakError
import pytest
from idasen_ha import Desk
from idasen_ha.connection_manager import AuthFailedError
from . import FAKE_BLE_DEVICE
async def test_connect_disconnect(mock_idasen_desk: MagicMock):
"""Test connect and disconnect."""
update_callback = Mock()
desk = Desk(update_callback, False)
await desk.connect(FAKE_BLE_DEVICE)
assert desk.is_connected
mock_idasen_desk.connect.assert_awaited()
mock_idasen_desk.pair.assert_called()
assert update_callback.call_count == 1
await desk.disconnect()
await desk.disconnect() # double disconnect should be a no-op
assert not desk.is_connected
mock_idasen_desk.disconnect.assert_called()
assert update_callback.call_count == 2
async def test_double_connect_call_with_same_bledevice(mock_idasen_desk: MagicMock):
"""Test connect being called again with the same BLEDevice, while still connecting."""
update_callback = Mock()
desk = Desk(update_callback, False)
default_connect_side_effect = mock_idasen_desk.connect.side_effect
async def connect_side_effect():
# call the seccond `connect` while the first is ongoing
await desk.connect(FAKE_BLE_DEVICE)
await default_connect_side_effect()
mock_idasen_desk.connect.side_effect = connect_side_effect
await desk.connect(FAKE_BLE_DEVICE)
assert desk.is_connected
mock_idasen_desk.connect.assert_awaited()
mock_idasen_desk.pair.assert_called()
assert update_callback.call_count == 1
async def test_double_connect_call_with_different_bledevice():
"""Test connect being called again with a new BLEDevice, while still connecting."""
with mock.patch(
"idasen_ha.connection_manager.IdasenDesk", autospec=True
) as patched_idasen_desk:
mock_idasen_desk = patched_idasen_desk.return_value
async def connect_side_effect():
# call the seccond `connect` while the first is ongoing
mock_idasen_desk.connect.side_effect = MagicMock()
new_ble_device = BLEDevice("AA:BB:CC:DD:EE:AA", None, None)
await desk.connect(new_ble_device)
mock_idasen_desk.is_connected = False
mock_idasen_desk.connect.side_effect = connect_side_effect
update_callback = Mock()
desk = Desk(update_callback, False)
await desk.connect(FAKE_BLE_DEVICE)
mock_idasen_desk.connect.assert_awaited()
mock_idasen_desk.pair.assert_called()
assert update_callback.call_count == 2
assert patched_idasen_desk.call_count == 2
@mock.patch("idasen_ha.connection_manager.asyncio.sleep")
async def test_connect_called_while_retry_pending(
sleep_mock,
mock_idasen_desk: MagicMock,
) -> None:
"""Test connect being called while a retry is pending."""
retry_maxed_future = asyncio.Future()
update_callback = Mock()
desk = Desk(update_callback, False)
default_connect_side_effect = mock_idasen_desk.connect.side_effect
async def sleep_side_effect(delay):
mock_idasen_desk.connect.side_effect = default_connect_side_effect
await desk.connect(FAKE_BLE_DEVICE)
retry_maxed_future.set_result(None)
sleep_mock.side_effect = sleep_side_effect
mock_idasen_desk.connect.side_effect = TimeoutError()
await desk.connect(FAKE_BLE_DEVICE)
assert not desk.is_connected
await retry_maxed_future
assert desk.is_connected
assert mock_idasen_desk.connect.call_count == 2
assert update_callback.call_count == 1
async def test_connect_raises_without_auto_reconnect(mock_idasen_desk: MagicMock):
"""Test that connect raises if auto_reconnect is False."""
desk = Desk(Mock(), False)
mock_idasen_desk.connect.side_effect = TimeoutError()
with pytest.raises(TimeoutError):
await desk.connect(FAKE_BLE_DEVICE, retry=False)
assert not desk.is_connected
@pytest.mark.parametrize(
("pair_exception", "raised_exception"),
[
(Exception(), Exception),
(BleakDBusError("org.bluez.Error.AuthenticationFailed", ""), AuthFailedError),
],
)
async def test_disconnect_on_pair_failure(
mock_idasen_desk: MagicMock, pair_exception, raised_exception
):
"""Test that disconnect is called if pair fails."""
update_callback = Mock()
desk = Desk(update_callback, False)
mock_idasen_desk.pair.side_effect = pair_exception
with pytest.raises(raised_exception):
await desk.connect(FAKE_BLE_DEVICE, retry=False)
assert not desk.is_connected
mock_idasen_desk.disconnect.assert_called()
assert update_callback.call_count == 0
@mock.patch("idasen_ha.connection_manager.asyncio.sleep")
@pytest.mark.parametrize("exception", [TimeoutError(), BleakError()])
@pytest.mark.parametrize("fail_call_name", ["connect", "pair"])
async def test_connect_exception_retry_with_disconnect(
sleep_mock,
mock_idasen_desk: MagicMock,
exception: Exception,
fail_call_name: str,
) -> None:
"""Test connect retries on connection exception."""
TEST_RETRIES_MAX = 3
retry_count = 0
retry_maxed_future = asyncio.Future()
async def sleep_handler(delay):
nonlocal retry_count
retry_count = retry_count + 1
if retry_count == TEST_RETRIES_MAX:
asyncio.get_event_loop().create_task(desk.disconnect())
retry_maxed_future.set_result(None)
sleep_mock.side_effect = sleep_handler
desk = Desk(Mock(), False)
getattr(mock_idasen_desk, fail_call_name).side_effect = exception
await desk.connect(FAKE_BLE_DEVICE)
await retry_maxed_future
assert mock_idasen_desk.connect.call_count == TEST_RETRIES_MAX + 1
@mock.patch("idasen_ha.connection_manager.asyncio.sleep")
@pytest.mark.parametrize(
"exception",
[
TimeoutError(),
BleakError(),
BleakDBusError("", []),
BleakDBusError("org.bluez.Error.AuthenticationFailed", []),
],
)
@pytest.mark.parametrize("fail_call_name", ["connect", "pair"])
async def test_connect_exception_retry_success(
sleep_mock,
mock_idasen_desk: MagicMock,
exception: Exception,
fail_call_name: str,
) -> None:
"""Test connect retries on connection exception."""
TEST_RETRIES_MAX = 3
retry_count = 0
retry_maxed_future = asyncio.Future()
fail_call = getattr(mock_idasen_desk, fail_call_name)
default_fail_call_side_effect = fail_call.side_effect
async def sleep_handler(delay):
nonlocal retry_count
if retry_count == TEST_RETRIES_MAX:
fail_call.side_effect = default_fail_call_side_effect
retry_maxed_future.set_result(None)
retry_count = retry_count + 1
sleep_mock.side_effect = sleep_handler
desk = Desk(Mock(), False)
fail_call.side_effect = exception
await desk.connect(FAKE_BLE_DEVICE)
await retry_maxed_future
assert mock_idasen_desk.connect.call_count == TEST_RETRIES_MAX + 2
async def test_reconnect_on_connection_drop(mock_idasen_desk: MagicMock):
"""Test reconnection when the connection drops."""
update_callback = Mock()
desk = Desk(update_callback, True)
await desk.connect(FAKE_BLE_DEVICE)
assert desk.is_connected
assert update_callback.call_count == 1
mock_idasen_desk.reset_mock()
await mock_idasen_desk.disconnect()
assert not desk.is_connected
assert update_callback.call_count == 2
await asyncio.sleep(0)
assert desk.is_connected
mock_idasen_desk.connect.assert_awaited()
mock_idasen_desk.pair.assert_called()
assert update_callback.call_count == 3
|
