def test_hosts_up(self, mock_service_is_up, mock_list_by_binary):
service1 = objects.ZunService(host='host1')
service2 = objects.ZunService(host='host2')
services = [service1, service2]
mock_list_by_binary.return_value = services
mock_service_is_up.side_effect = [False, True]
result = self.driver.hosts_up(self.context)
self.assertEqual(result, ['host2'])
mock_list_by_binary.assert_called_once_with(self.context,
'zun-compute')
calls = [mock.call(service1), mock.call(service2)]
self.assertEqual(calls, mock_service_is_up.call_args_list)
def test_create(self):
with mock.patch.object(self.dbapi, 'create_zun_service',
autospec=True) as mock_create_zun_service:
mock_create_zun_service.return_value = self.fake_zun_service
ms_dict = {'host': 'fakehost', 'binary': 'fake-bin'}
ms = objects.ZunService(self.context, **ms_dict)
ms.create(self.context)
mock_create_zun_service.assert_called_once_with(ms_dict)
def test_container_stats(self, mock_srv_list, mock_srv_up, mock_call):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_stats(self.context, container)
mock_call.assert_called_once_with(container.host,
"container_stats",
container=container)
def test_compute_filter_sgapi_passes(self, service_up_mock):
filt_cls = compute_filter.ComputeFilter()
container = objects.Container(self.context)
service = objects.ZunService(self.context)
service.disabled = False
extra_spec = {}
host = fakes.FakeHostState('host2', {'service': service})
service_up_mock.return_value = True
self.assertTrue(filt_cls.host_passes(host, container, extra_spec))
service_up_mock.assert_called_once_with(service)
def test_compute_filter_manual_disable(self, service_up_mock):
filt_cls = compute_filter.ComputeFilter()
container = objects.Container(self.context)
extra_spec = {}
service = objects.ZunService(self.context)
service.disabled = True
service.disabled_reason = 'This is a reason!'
host = fakes.FakeHostState('host1', {'service': service})
self.assertFalse(filt_cls.host_passes(host, container, extra_spec))
self.assertFalse(service_up_mock.called)
def test_container_delete_with_host_no_tup(self, mock_rpc_call,
mock_list, mock_service_is_up):
test_container = utils.get_test_container()
test_container_obj = objects.Container(self.context, **test_container)
test_service = utils.get_test_zun_service(host="fake_host")
test_service_obj = objects.ZunService(self.context, **test_service)
mock_list.return_value = [test_service_obj]
mock_service_is_up.return_value = False
self.assertRaises(exception.ContainerHostNotUp,
self.compute_rpcapi.container_delete,
self.context, test_container_obj, False)
def test_compute_filter_sgapi_fails(self, service_up_mock):
filts_cls = compute_filter.ComputeFilter()
container = objects.Container(self.context)
service = objects.ZunService(self.context)
service.disabled = False
service.updated_at = timeutils.utcnow()
extra_spec = {}
host = fakes.FakeHostState('host3', {'service': service})
service_up_mock.return_value = False
self.assertFalse(filts_cls.host_passes(host, container, extra_spec))
service_up_mock.assert_called_once_with(service)
def _test_az_filter(self, request_az, node_az):
filt_cls = az_filter.AvailabilityZoneFilter()
container = objects.Container(self.context)
service = objects.ZunService(self.context)
service.availability_zone = node_az
extra_spec = {}
if request_az:
extra_spec = {'availability_zone': request_az}
host = fakes.FakeHostState('fake-host',
{'service': service})
return filt_cls.host_passes(host, container, extra_spec)
def update_zun_service(self, ctx):
LOG.debug('Update zun_service')
if self.zun_service_ref is None:
self.zun_service_ref = \
objects.ZunService.get_by_host_and_binary(
ctx, self.host, self.binary)
if self.zun_service_ref is None:
zun_service_dict = {'host': self.host, 'binary': self.binary}
self.zun_service_ref = objects.ZunService(
ctx, **zun_service_dict)
self.zun_service_ref.create()
self.zun_service_ref.report_state_up()
def test_container_exec(self, mock_srv_list, mock_srv_up, mock_call):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_exec(self.context, container, "/bin/bash",
True, True)
mock_call.assert_called_once_with(container.host,
"container_exec",
container=container,
command="/bin/bash",
run=True,
interactive=True)
def test_container_get_archive(self, mock_srv_list, mock_srv_up,
mock_call):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_get_archive(self.context, container,
"/root", True)
mock_call.assert_called_once_with(container.host,
"container_get_archive",
container=container,
path="/root",
encode_data=True)
def test_container_attach(self, mock_srv_list, mock_srv_up, mock_call):
mock_call.return_value = 'fake-token'
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
url = self.compute_api.container_attach(self.context, container)
mock_call.assert_called_once_with(container.host,
"container_attach",
container=container)
expected_url = '%s?token=%s&uuid=%s' % (CONF.websocket_proxy.base_url,
'fake-token', container.uuid)
self.assertEqual(expected_url, url)
def test_container_exec_resize(self, mock_srv_list, mock_srv_up,
mock_call):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_exec_resize(self.context, container, '123',
10, 5)
mock_call.assert_called_once_with(container.host,
"container_exec_resize",
exec_id='123',
height=10,
width=5)
def test_container_logs(self, mock_srv_list, mock_srv_up, mock_call):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_logs(self.context, container, 1, 1, 1, 1, 1)
mock_call.assert_called_once_with(container.host,
"container_logs",
container=container,
stdout=1,
stderr=1,
timestamps=1,
tail=1,
since=1)
def test_get_all_availability_zones(self, mock_availability_zone_list,
mock_policy):
mock_policy.return_value = True
test_a_zone = utils.get_test_zun_service()
availability_zones = [objects.ZunService(self.context, **test_a_zone)]
mock_availability_zone_list.return_value = availability_zones
response = self.get('/v1/availability_zones')
mock_availability_zone_list.assert_called_once_with(
mock.ANY, 1000, None, 'availability_zone', 'asc')
self.assertEqual(200, response.status_int)
actual_a_zones = response.json['availability_zones']
self.assertEqual(1, len(actual_a_zones))
self.assertEqual(test_a_zone['availability_zone'],
actual_a_zones[0].get('availability_zone'))
def test_container_delete(self, mock_start, mock_srv_list, mock_srv_up,
mock_cast):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_delete(self.context, container, False)
mock_start.assert_called_once_with(self.context,
container.uuid,
container_actions.DELETE,
want_result=False)
mock_cast.assert_called_once_with(container.host,
"container_delete",
container=container,
force=False)
def test_container_commit(self, mock_start, mock_srv_list, mock_srv_up,
mock_call):
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
self.compute_api.container_commit(self.context, container, "ubuntu",
"latest")
mock_start.assert_called_once_with(self.context,
container.uuid,
container_actions.COMMIT,
want_result=False)
mock_call.assert_called_once_with(container.host,
"container_commit",
container=container,
repository="ubuntu",
tag="latest")
def test_container_exec_interactive(self, mock_srv_list, mock_srv_up,
mock_call):
mock_call.return_value = {
'token': 'fake-token',
'exec_id': 'fake-exec-id'
}
container = self.container
srv = objects.ZunService(
self.context, **utils.get_test_zun_service(host=container.host))
mock_srv_list.return_value = [srv]
mock_srv_up.return_value = True
result = self.compute_api.container_exec(self.context, container,
"/bin/bash", True, True)
self.assertIn('fake-token', result['proxy_url'])
self.assertIn('fake-exec-id', result['proxy_url'])
mock_call.assert_called_once_with(container.host,
"container_exec",
container=container,
command="/bin/bash",
run=True,
interactive=True)
