async def test_select_scene(opp, device, main_zone, caplog):
"""Test select scene service."""
scene_prop = PropertyMock(return_value=None)
type(main_zone).scene = scene_prop
assert await async_setup_component(opp, mp.DOMAIN, CONFIG)
await opp.async_block_till_done()
scene = "TV Viewing"
data = {
"entity_id": "media_player.yamaha_receiver_main_zone",
"scene": scene,
}
await opp.services.async_call(DOMAIN, yamaha.SERVICE_SELECT_SCENE, data, True)
assert scene_prop.call_count == 1
assert scene_prop.call_args == call(scene)
scene = "BD/DVD Movie Viewing"
data["scene"] = scene
await opp.services.async_call(DOMAIN, yamaha.SERVICE_SELECT_SCENE, data, True)
assert scene_prop.call_count == 2
assert scene_prop.call_args == call(scene)
scene_prop.side_effect = AssertionError()
missing_scene = "Missing scene"
data["scene"] = missing_scene
await opp.services.async_call(DOMAIN, yamaha.SERVICE_SELECT_SCENE, data, True)
assert f"Scene '{missing_scene}' does not exist!" in caplog.text
def test_writing_is_threadsafe(self, lcd_mock_class):
lcd_mock = lcd_mock_class.return_value
cursor_mock = PropertyMock()
cursor_mock.side_effect = self.__delay
type(lcd_mock).cursor_pos = cursor_mock
display = Display(["environment"], ["heater"])
manager = Mock()
manager.attach_mock(lcd_mock, 'lcd_mock')
manager.cursor_mock = cursor_mock
t1 = Thread(target=display.handle_temperature, args=("environment", 12.3, 3))
t2 = Thread(target=display.handle_switch, args=("heater", True,))
t1.start()
t2.start()
t1.join()
t2.join()
calls_in_order = [
call.cursor_mock((0, 0)),
call.lcd_mock.write_string("E 12.3"),
call.cursor_mock((0, 14)),
call.lcd_mock.write_string("H")
]
assert manager.mock_calls == calls_in_order
def vm_mock2():
vm = Mock()
all_ips_mock = PropertyMock()
type(vm).all_ips = all_ips_mock
all_ips_mock.side_effect = [[
'WORKING_IP_MOCK', 'SHOULD_NOT_REACH_THIS_MOCK'
]]
return vm
def test_get_internal_project(self, sleep: MagicMock,
internal_project: PropertyMock):
"""Should get internal project on the third attempt"""
project = exposed.ExposedProject()
internal_project.side_effect = [None, None, 'test']
result = project.get_internal_project()
self.assertEqual('test', result)
self.assertEqual(2, sleep.call_count)
def test_dac_throws_always(self, gpio, dac, swim_pump_device):
normalized_value = PropertyMock()
normalized_value.side_effect = OSError()
type(dac).normalized_value = normalized_value
swim_pump_device.speed(50)
gpio.output.assert_has_calls([call(PIN, True), call(PIN, False)])
normalized_value.assert_called_with(0.5)
assert normalized_value.call_count == 3
def test_get_internal_project(
self,
sleep: MagicMock,
internal_project: PropertyMock
):
"""Should get internal project on the third attempt"""
project = exposed.ExposedProject()
internal_project.side_effect = [None, None, 'test']
result = project.get_internal_project()
self.assertEqual('test', result)
self.assertEqual(2, sleep.call_count)
def test_url(self, mock__auth: PropertyMock) -> None:
"""Testign getter of the proxy URL"""
mock__auth.side_effect = lambda: 'L:P@'
proxy: Proxy = Proxy()
proxy.ip = ''
proxy.port = 81
proxy.protocol = 'HTTP'
self.assertEqual(proxy.url, '')
mock__auth.assert_not_called()
proxy.ip = 'IP'
self.assertEqual(proxy.url, 'HTTP://*****:*****@IP:81')
mock__auth.assert_called_once_with()
def test_dac_throws_once(self, gpio, dac, swim_pump_device):
def side_effect(value):
side_effect.counter += 1
if side_effect.counter == 1:
raise OSError()
return DEFAULT
side_effect.counter = 0
normalized_value = PropertyMock()
normalized_value.side_effect = side_effect
type(dac).normalized_value = normalized_value
swim_pump_device.speed(50)
gpio.output.assert_has_calls([call(PIN, True), call(PIN, False)])
normalized_value.assert_called_with(0.5)
assert normalized_value.call_count == 2
def test__str(self, mock_url: PropertyMock) -> None:
"""Testing __str__ of Proxy"""
mock_url.side_effect = lambda: 'URL'
proxy: Proxy = Proxy()
self.assertEqual(str(proxy), 'URL')
mock_url.assert_called_once_with()
