def test_lifecycle(capture, machine, strokes):
# Start machine.
machine.start_capture()
assert capture.mock_calls == [
call.suppress_keyboard(()),
call.start(),
]
capture.reset_mock()
machine.set_suppression(True)
suppressed_keys = dict(machine.keymap.get_bindings())
del suppressed_keys['space']
assert strokes == []
assert capture.mock_calls == [
call.suppress_keyboard(suppressed_keys.keys()),
]
# Trigger some strokes.
capture.reset_mock()
send_input(capture, '+a +h -a -h space w')
assert strokes == [
{'S-', '*'},
{'T-'},
]
assert capture.mock_calls == []
# Stop machine.
del strokes[:]
machine.stop_capture()
assert strokes == []
assert capture.mock_calls == [
call.suppress_keyboard(()),
call.cancel(),
]
def test_101_run_pass_file(self):
self.app.expected_calls[('dom0', 'admin.vm.List', None, None)] = (
b'0\0dom0 class=AdminVM state=Running\n'
b'fedora-25 class=TemplateVM state=Halted\n'
)
args = unittest.mock.Mock(backup_location='/backup/path',
pass_file='/some/path',
appvm=None)
obj = RestoreInDisposableVM(self.app, args)
methods = ['create_dispvm', 'clear_old_tags', 'register_backup_source',
'prepare_inner_args', 'extract_log', 'finalize_tags',
'transfer_pass_file']
for m in methods:
setattr(obj, m, unittest.mock.Mock())
obj.extract_log.return_value = b'Some logs\nexit code: 0\n'
obj.prepare_inner_args.return_value = ['args']
obj.terminal_app = ('terminal',)
obj.dispvm = unittest.mock.Mock()
with tempfile.NamedTemporaryFile() as tmp:
with unittest.mock.patch('qubesadmin.backup.dispvm.LOCKFILE',
tmp.name):
obj.run()
for m in methods:
self.assertEqual(len(getattr(obj, m).mock_calls), 1)
self.assertEqual(obj.dispvm.mock_calls, [
call.start(),
call.run_service_for_stdio('qubes.WaitForSession'),
call.tags.add('backup-restore-mgmt'),
call.run_with_args('terminal', 'qvm-backup-restore', 'args',
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL),
call.tags.discard('backup-restore-mgmt'),
call.kill()
])
def test_lifecycle(capture, machine, strokes):
# Start machine.
machine.start_capture()
assert capture.mock_calls == [
call.suppress_keyboard(()),
call.start(),
]
capture.reset_mock()
machine.set_suppression(True)
suppressed_keys = dict(machine.keymap.get_bindings())
del suppressed_keys['space']
assert strokes == []
assert capture.mock_calls == [
call.suppress_keyboard(suppressed_keys.keys()),
]
# Trigger some strokes.
capture.reset_mock()
send_input(capture, '+a +h -a -h space w')
assert strokes == [
{'S-', '*'},
{'T-'},
]
assert capture.mock_calls == []
# Stop machine.
del strokes[:]
machine.stop_capture()
assert strokes == []
assert capture.mock_calls == [
call.suppress_keyboard(()),
call.cancel(),
]
def test_setup_auto_start_disabled(self, mock_homekit):
"""Test async_setup with auto start disabled and test service calls."""
mock_homekit.return_value = homekit = Mock()
config = {
DOMAIN: {
CONF_AUTO_START: False,
CONF_PORT: 11111,
CONF_IP_ADDRESS: '172.0.0.0'
}
}
self.assertTrue(setup.setup_component(self.hass, DOMAIN, config))
self.hass.bus.fire(EVENT_HOMEASSISTANT_START)
self.hass.block_till_done()
self.assertEqual(
mock_homekit.mock_calls,
[call(self.hass, 11111, '172.0.0.0', ANY, {}),
call().setup()])
# Test start call with driver stopped.
homekit.reset_mock()
homekit.configure_mock(**{'started': False})
self.hass.services.call('homekit', 'start')
self.assertEqual(homekit.mock_calls, [call.start()])
# Test start call with driver started.
homekit.reset_mock()
homekit.configure_mock(**{'started': True})
self.hass.services.call(DOMAIN, SERVICE_HOMEKIT_START)
self.assertEqual(homekit.mock_calls, [])
def test_setup_auto_start_disabled(self, mock_homekit):
"""Test async_setup with auto start disabled and test service calls."""
mock_homekit.return_value = homekit = Mock()
config = {DOMAIN: {CONF_AUTO_START: False, CONF_PORT: 11111}}
self.assertTrue(setup.setup_component(
self.hass, DOMAIN, config))
self.hass.bus.fire(EVENT_HOMEASSISTANT_START)
self.hass.block_till_done()
self.assertEqual(mock_homekit.mock_calls, [
call(self.hass, 11111, ANY, {}),
call().setup()])
# Test start call with driver stopped.
homekit.reset_mock()
homekit.configure_mock(**{'started': False})
self.hass.services.call('homekit', 'start')
self.assertEqual(homekit.mock_calls, [call.start()])
# Test start call with driver started.
homekit.reset_mock()
homekit.configure_mock(**{'started': True})
self.hass.services.call(DOMAIN, SERVICE_HOMEKIT_START)
self.assertEqual(homekit.mock_calls, [])
def test_monitor_multiple_start():
"""
Calling ``Monitor.start`` multiple times has no effects beyond those of
calling it once.
"""
monitor = Monitor(MagicMock())
monitor.timer = MagicMock()
monitor.start()
monitor.start()
assert monitor.timer.mock_calls == [call.start(2, now=True)]
def test_add_player_start_game_calls_methods_on_turns():
""" Tests add_player, start_game and Player """
board = Board()
turns = Mock()
game = Game(identifier=0, board=board, turns=turns)
for _ in range(4):
player_id = game.unused_player_id()
game.add_player(Player(player_id))
game.start_game()
expected_turn_calls = [call.init(game.players)] + [call.start()]
assert turns.mock_calls[-2:] == expected_turn_calls
async def test_observer_discovery(hass, hass_ws_client, venv):
"""Test that observer can discover a device without raising an exception."""
new_usb = [{"domain": "test1", "vid": "3039"}]
mock_comports = [
MagicMock(
device=slae_sh_device.device,
vid=12345,
pid=12345,
serial_number=slae_sh_device.serial_number,
manufacturer=slae_sh_device.manufacturer,
description=slae_sh_device.description,
)
]
mock_observer = None
async def _mock_monitor_observer_callback(callback):
await hass.async_add_executor_job(
callback, MagicMock(action="create", device_path="/dev/new")
)
def _create_mock_monitor_observer(monitor, callback, name):
nonlocal mock_observer
hass.async_create_task(_mock_monitor_observer_callback(callback))
mock_observer = MagicMock()
return mock_observer
with patch("pyudev.Context"), patch(
"pyudev.MonitorObserver", new=_create_mock_monitor_observer
), patch("pyudev.Monitor.filter_by"), patch(
"homeassistant.components.usb.async_get_usb", return_value=new_usb
), patch(
"homeassistant.components.usb.comports", return_value=mock_comports
), patch.object(
hass.config_entries.flow, "async_init"
) as mock_config_flow:
assert await async_setup_component(hass, "usb", {"usb": {}})
await hass.async_block_till_done()
hass.bus.async_fire(EVENT_HOMEASSISTANT_STARTED)
await hass.async_block_till_done()
assert len(mock_config_flow.mock_calls) == 1
assert mock_config_flow.mock_calls[0][1][0] == "test1"
hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)
await hass.async_block_till_done()
assert mock_observer.mock_calls == [call.start(), call.stop()]
def test_homekit_start(self, mock_add_bridge_acc, mock_show_setup_msg):
"""Test HomeKit start method."""
homekit = HomeKit(self.hass, None, None, {}, {'cover.demo': {}})
homekit.bridge = HomeBridge(self.hass)
homekit.driver = Mock()
self.hass.states.set('light.demo', 'on')
state = self.hass.states.all()[0]
homekit.start()
self.assertEqual(mock_add_bridge_acc.mock_calls, [call(state)])
self.assertEqual(mock_show_setup_msg.mock_calls,
[call(self.hass, homekit.bridge)])
self.assertEqual(homekit.driver.mock_calls, [call.start()])
self.assertTrue(homekit.started)
# Test start() if already started
homekit.driver.reset_mock()
homekit.start()
self.assertEqual(homekit.driver.mock_calls, [])
def test_homekit_start(self, mock_add_bridge_acc, mock_show_setup_msg):
"""Test HomeKit start method."""
homekit = HomeKit(self.hass, None, {}, {'cover.demo': {}})
homekit.bridge = HomeBridge(self.hass)
homekit.driver = Mock()
self.hass.states.set('light.demo', 'on')
state = self.hass.states.all()[0]
homekit.start()
self.assertEqual(mock_add_bridge_acc.mock_calls, [call(state)])
self.assertEqual(mock_show_setup_msg.mock_calls, [
call(self.hass, homekit.bridge)])
self.assertEqual(homekit.driver.mock_calls, [call.start()])
self.assertTrue(homekit.started)
# Test start() if already started
homekit.driver.reset_mock()
homekit.start()
self.assertEqual(homekit.driver.mock_calls, [])
def _check_timer_called(self):
self.assertListEqual([call.start()],
self.timer_mock.return_value.method_calls)
def test_monitor_start():
monitor = Monitor(MagicMock())
monitor.timer = MagicMock()
monitor.start()
assert monitor.timer.mock_calls == [call.start(2, now=True)]
def test_awsec2_class(resman):
with patch('boto3.resource') as client, \
patch.object(SSH, 'get_session', return_value='started_session'), \
swallow_logs(new_level=logging.DEBUG) as log:
# Test connecting when a resource doesn't exist.
client.return_value = MagicMock(instances=MagicMock(
filter=lambda Filters: []))
config = {
'name': 'non-existent-instance',
'type': 'aws-ec2',
'access_key_id': 'my-aws-access-key-id',
'secret_access_key': 'my-aws-secret-access-key-id'
}
resource = resman.factory(config)
resource.connect()
assert resource.id is None
assert resource.status is None
# Test catching exception when multiple resources are found at connection.
client.return_value = MagicMock(instances=MagicMock(
filter=lambda Filters: [
MagicMock(instance_id='i-22221ddf096c22bb0',
state={'Name': 'running'}),
MagicMock(instance_id='i-3333f40de2b9b8967',
state={'Name': 'running'})
]))
config = {
'name': 'duplicate-instance-name',
'type': 'aws-ec2',
'access_key_id': 'my-aws-access-key-id',
'secret_access_key': 'my-aws-secret-access-key-id'
}
resource = resman.factory(config)
try:
resource.connect()
except Exception as e:
assert e.args[0] == "Multiple container matches found"
# Test connecting to an existing resource.
client.return_value = MagicMock(Instance=lambda id: MagicMock(
instance_id='i-00002777d52482d9c', state={'Name': 'running'}))
config = {
'name': 'my-instance-name',
'id': 'i-00002777d52482d9c',
'type': 'aws-ec2',
'access_key_id': 'my-aws-access-key-id',
'secret_access_key': 'my-aws-secret-access-key-id',
'key_name': 'my-ssh-key',
'key_filename': '/home/me/.ssh/id_rsa'
}
resource = resman.factory(config)
resource.connect()
assert resource.image == 'ami-c8580bdf'
assert resource.id == 'i-00002777d52482d9c'
assert resource.instance_type == 't2.micro'
assert resource.key_filename == '/home/me/.ssh/id_rsa'
assert resource.key_name == 'my-ssh-key'
assert resource.name == 'my-instance-name'
assert resource.region_name == 'us-east-1'
assert resource.access_key_id == 'my-aws-access-key-id'
assert resource.secret_access_key == 'my-aws-secret-access-key-id'
assert resource.security_group == 'default'
assert resource.status == 'running'
assert resource.type == 'aws-ec2'
# Test creating an existing resource and catch the exception.
try:
list(resource.create())
except Exception as e:
assert e.args[
0] == "Instance 'i-00002777d52482d9c' already exists in AWS subscription"
# Test creating resource.
client.return_value = MagicMock(
instances=MagicMock(filter=lambda Filters: []),
Instance=lambda id: MagicMock(instance_id='i-11112777d52482d9c',
state={'Name': 'pending'}))
config = {
'name': 'my-instance-name',
'type': 'aws-ec2',
'access_key_id': 'my-aws-access-key-id',
'secret_access_key': 'my-aws-secret-access-key-id',
'key_name': 'my-ssh-key',
'key_filename': '/home/me/.ssh/id_rsa'
}
resource = resman.factory(config)
resource.connect()
# Test retrieving more than one yield from the create method
create_generator = resource.create()
result_1 = next(create_generator)
assert result_1['id'] == 'i-11112777d52482d9c'
assert result_1['status'] == 'pending'
resource._ec2_instance.state['Name'] = 'running'
result_2 = next(create_generator)
assert result_2['status'] == 'running'
assert_in('EC2 instance i-11112777d52482d9c initialized!', log.lines)
assert_in('EC2 instance i-11112777d52482d9c is running!', log.lines)
assert_in(
'Waiting for EC2 instance i-11112777d52482d9c to complete initialization...',
log.lines)
assert_in('EC2 instance i-11112777d52482d9c initialized!', log.lines)
# Test stopping resource.
resource.stop()
calls = [call.stop()]
resource._ec2_instance.assert_has_calls(calls, any_order=True)
# Test starting resource.
resource.start()
calls = [call.start()]
resource._ec2_instance.assert_has_calls(calls, any_order=True)
# Test deleting resource.
resource.delete()
calls = [call.terminate()]
resource._ec2_instance.assert_has_calls(calls, any_order=True)
session = resource.get_session()
assert session == 'started_session'
def test_watch_directory_schedules_then_starts_observer(self, Observer):
handler = MagicMock()
tasks.watch_directory(handler, PATH)
expected_calls = [call.schedule(handler, PATH), call.start()]
self.assertEqual(Observer().mock_calls, expected_calls)
