def test_get_all_capsules_all_projects(self, mock_container_get_by_uuid,
mock_capsule_list,
mock_container_show):
test_container = utils.get_test_container()
test_container_obj = objects.Container(self.context, **test_container)
mock_container_get_by_uuid.return_value = test_container_obj
test_capsule = utils.create_test_container(context=self.context)
test_capsule_obj = objects.Capsule(self.context, **test_capsule)
mock_capsule_list.return_value = [test_capsule_obj]
mock_container_show.return_value = test_container_obj
response = self.app.get('/v1/capsules/?all_projects=1')
mock_capsule_list.assert_called_once_with(mock.ANY,
1000,
None,
'id',
'asc',
filters=None)
context = mock_capsule_list.call_args[0][0]
self.assertIs(True, context.all_projects)
self.assertEqual(200, response.status_int)
actual_capsules = response.json['capsules']
self.assertEqual(1, len(actual_capsules))
self.assertEqual(test_capsule['uuid'], actual_capsules[0].get('uuid'))
def test_unpause_by_name(self, mock_container_unpause, mock_validate):
test_container_obj = objects.Container(self.context,
**utils.get_test_container())
mock_container_unpause.return_value = test_container_obj
test_container = utils.get_test_container()
self._action_test(test_container, 'unpause', 'name',
mock_container_unpause, 202)
def test_get_all_capsules_with_pagination_marker(
self, mock_container_get_by_uuid, mock_capsule_save,
mock_capsule_list, mock_capsule_show):
test_container = utils.get_test_container()
test_container_obj = objects.Container(self.context, **test_container)
mock_container_get_by_uuid.return_value = test_container_obj
capsule_list = []
for id_ in range(4):
test_capsule = utils.create_test_container(
id=id_,
uuid=uuidutils.generate_uuid(),
name='capsule' + str(id_),
context=self.context)
capsule_list.append(objects.Capsule(self.context, **test_capsule))
mock_capsule_list.return_value = capsule_list[-1:]
mock_capsule_show.return_value = capsule_list[-1]
mock_capsule_save.return_value = True
response = self.app.get('/v1/capsules/?limit=3&marker=%s' %
capsule_list[2].uuid)
self.assertEqual(200, response.status_int)
actual_capsules = response.json['capsules']
self.assertEqual(1, len(actual_capsules))
self.assertEqual(actual_capsules[-1].get('uuid'),
actual_capsules[0].get('uuid'))
def test_start_by_name(self, mock_container_start, mock_validate):
test_container_obj = objects.Container(self.context,
**utils.get_test_container())
mock_container_start.return_value = test_container_obj
test_container = utils.get_test_container()
self._action_test(test_container, 'start', 'name',
mock_container_start, 202)
def _action_test(self,
container,
action,
ident_field,
mock_container_action,
status_code,
query_param=''):
test_container_obj = objects.Container(self.context, **container)
ident = container.get(ident_field)
get_by_ident_loc = 'zun.objects.Container.get_by_%s' % ident_field
with patch(get_by_ident_loc) as mock_get_by_indent:
mock_get_by_indent.return_value = test_container_obj
response = self.app.post('/v1/containers/%s/%s/?%s' %
(ident, action, query_param))
self.assertEqual(status_code, response.status_int)
# Only PUT should work, others like GET should fail
self.assertRaises(AppError, self.app.get,
('/v1/containers/%s/%s/' % (ident, action)))
if query_param:
value = query_param.split('=')[1]
mock_container_action.assert_called_once_with(
mock.ANY, test_container_obj, value)
else:
mock_container_action.assert_called_once_with(
mock.ANY, test_container_obj)
def setUp(self):
super(TestAPI, self).setUp()
self.compute_api = api.API(self.context)
self.container = objects.Container(self.context,
**utils.get_test_container())
self.network = objects.Network(self.context,
**utils.get_test_network())
def test_cpuset_filter_fail_dedicated_2(self):
self.filt_cls = cpuset_filter.CpuSetFilter()
container = objects.Container(self.context)
container.cpu_policy = 'dedicated'
container.cpu = 2.0
container.memory = '1024'
host = fakes.FakeHostState('testhost')
host.cpus = 6
host.cpu_used = 0.0
host.numa_topology = objects.NUMATopology(nodes=[
objects.NUMANode(id=0,
cpuset=set([1, 2, 3]),
pinned_cpus=set([]),
mem_total=32739,
mem_available=32739),
objects.NUMANode(id=1,
cpuset=set([4, 5, 6]),
pinned_cpus=set([]),
mem_total=32739,
mem_available=32739)
])
host.enable_cpu_pinning = False
extra_spec = {}
self.assertFalse(self.filt_cls.host_passes(host, container,
extra_spec))
def test_delete_capsule_by_uuid_all_projects(self,
mock_capsule_save,
mock_container_get_by_uuid,
mock_capsule_get_by_uuid,
mock_capsule_delete,
mock_policy):
mock_policy.return_value = True
test_container = utils.get_test_container()
test_container_obj = objects.Container(self.context, **test_container)
mock_container_get_by_uuid.return_value = test_container_obj
test_capsule = utils.get_test_capsule()
test_capsule_obj = objects.Capsule(self.context,
**test_capsule)
mock_capsule_get_by_uuid.return_value = test_capsule_obj
mock_capsule_save.return_value = True
mock_capsule_delete.return_value = True
capsule_uuid = test_capsule.get('uuid')
response = self.app.delete(
'/capsules/%s/?all_projects=1' % capsule_uuid)
self.assertTrue(mock_capsule_delete.called)
self.assertEqual(204, response.status_int)
context = mock_capsule_save.call_args[0][0]
self.assertIs(True, context.all_projects)
def test_kill_container_by_name(self, mock_get_by_name,
mock_container_kill, mock_validate):
test_container_obj = objects.Container(self.context,
**utils.get_test_container())
mock_container_kill.return_value = test_container_obj
test_container = utils.get_test_container()
test_container_obj = objects.Container(self.context, **test_container)
mock_get_by_name.return_value = test_container_obj
container_name = test_container.get('name')
url = '/v1/containers/%s/%s/' % (container_name, 'kill')
cmd = {'signal': '9'}
response = self.app.post(url, cmd)
self.assertEqual(202, response.status_int)
mock_container_kill.assert_called_once_with(mock.ANY,
test_container_obj,
cmd['signal'])
def test_runtime_filter_specificed(self):
self.filt_cls = runtime_filter.RuntimeFilter()
container = objects.Container(self.context)
container.runtime = 'runc'
host = fakes.FakeHostState('testhost')
host.runtimes = ['runc']
extra_spec = {}
self.assertTrue(self.filt_cls.host_passes(host, container, extra_spec))
def test_label_filter_pass(self):
self.filt_cls = label_filter.LabelFilter()
container = objects.Container(self.context)
container.name = 'test-container'
extra_spec = {'label:type': 'test'}
host = objects.ComputeNode(self.context)
host.labels = {'type': 'test'}
self.assertTrue(self.filt_cls.host_passes(host, container, extra_spec))
def test_ram_filter_pass(self):
self.filt_cls = ram_filter.RamFilter()
container = objects.Container(self.context)
container.memory = '1024M'
host = HostState('testhost')
host.mem_total = 1024 * 128
host.mem_used = 1024
extra_spec = {}
self.assertTrue(self.filt_cls.host_passes(host, container, extra_spec))
def test_runtime_filter_not_supported(self):
self.filt_cls = runtime_filter.RuntimeFilter()
container = objects.Container(self.context)
container.runtime = 'runc'
host = fakes.FakeHostState('testhost')
host.runtimes = ['kata-runtime']
extra_spec = {}
self.assertFalse(self.filt_cls.host_passes(host, container,
extra_spec))
def test_label_filter_fail(self):
self.filt_cls = label_filter.LabelFilter()
container = objects.Container(self.context)
container.name = 'test-container'
extra_spec = {'hints': {'label:type': 'test'}}
host = objects.ComputeNode(self.context)
host.labels = {'type': 'production'}
self.assertFalse(self.filt_cls.host_passes(host, container,
extra_spec))
def test_get_logs_put_fails(self, mock_get_by_uuid, mock_container_logs):
test_container = utils.get_test_container()
test_container_obj = objects.Container(self.context, **test_container)
mock_get_by_uuid.return_value = test_container_obj
container_uuid = test_container.get('uuid')
self.assertRaises(AppError, self.app.post,
'/v1/containers/%s/logs/' % container_uuid)
self.assertFalse(mock_container_logs.called)
def test_cpu_filter_pass(self):
self.filt_cls = cpu_filter.CPUFilter()
container = objects.Container(self.context)
container.cpu = 5.0
host = fakes.FakeHostState('testhost')
host.cpus = 8
host.cpu_used = 0.0
extra_spec = {}
self.assertTrue(self.filt_cls.host_passes(host, container, extra_spec))
def test_create(self):
with mock.patch.object(self.dbapi, 'create_container',
autospec=True) as mock_create_container:
mock_create_container.return_value = self.fake_container
container = objects.Container(self.context, **self.fake_container)
container.create(self.context)
mock_create_container.assert_called_once_with(self.context,
self.fake_container)
self.assertEqual(self.context, container._context)
def test_disk_filter_pass(self):
self.filt_cls = disk_filter.DiskFilter()
container = objects.Container(self.context)
container.disk = 20
host = fakes.FakeHostState('testhost')
host.disk_total = 80
host.disk_used = 40
host.disk_quota_supported = True
extra_spec = {}
self.assertTrue(self.filt_cls.host_passes(host, container, extra_spec))
def test_select_destinations_no_valid_host(self, mock_hosts_up):
def _return_no_host(*args, **kwargs):
return []
mock_hosts_up.side_effect = _return_no_host
test_container = utils.get_test_container()
containers = [objects.Container(self.context, **test_container)]
self.assertRaises(exception.NoValidHost,
self.driver_cls().select_destinations, self.context,
containers)
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_ram_filter_fail(self):
self.filt_cls = ram_filter.RamFilter()
container = objects.Container(self.context)
container.memory = '4096'
host = fakes.FakeHostState('testhost')
host.mem_total = 1024 * 128
host.mem_used = 1024 * 127
extra_spec = {}
self.assertFalse(self.filt_cls.host_passes(host, container,
extra_spec))
def test_cpu_filter_fail(self):
self.filt_cls = cpu_filter.CPUFilter()
container = objects.Container(self.context)
container.cpu = 8.0
host = HostState('testhost')
host.cpus = 5
host.cpu_used = 2.0
extra_spec = {}
self.assertFalse(self.filt_cls.host_passes(host, container,
extra_spec))
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_pci_passthrough_with_pci_stats_none(self):
request = objects.ContainerPCIRequest(
count=1, spec=[{'vendor_id': '8086'}])
requests = objects.ContainerPCIRequests(requests=[request])
container = objects.Container(self.context)
host = HostState('testhost')
host.pci_stats = None
extra_spec = {'pci_requests': requests}
self.assertFalse(self.filt_cls.host_passes(host, container,
extra_spec))
def test_reboot_by_name(self, mock_container_reboot, mock_validate):
test_container_obj = objects.Container(self.context,
**utils.get_test_container())
mock_container_reboot.return_value = test_container_obj
test_container = utils.get_test_container()
self._action_test(test_container,
'reboot',
'name',
mock_container_reboot,
202,
query_param='timeout=10')
def setUp(self):
super(TestAPI, self).setUp()
p = mock.patch('zun.scheduler.client.query.SchedulerClient')
p.start()
self.addCleanup(p.stop)
self.compute_api = api.API(self.context)
self.container = objects.Container(self.context,
**utils.get_test_container())
self.network = objects.ZunNetwork(self.context,
**utils.get_test_network())
def get_test_container(context, **kwargs):
"""Return a test container object with appropriate attributes.
NOTE: The object leaves the attributes marked as changed, such
that a create() could be used to commit it to the DB.
"""
db_container = db_utils.get_test_container(**kwargs)
container = objects.Container(context)
for key in db_container:
setattr(container, key, db_container[key])
return container
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_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_status_reason_in_fields(self):
with mock.patch.object(self.dbapi, 'create_container',
autospec=True) as mock_create_container:
mock_create_container.return_value = self.fake_container
container = objects.Container(self.context, **self.fake_container)
self.assertTrue(hasattr(container, 'status_reason'))
container.status_reason = "Docker Error happened"
container.create(self.context)
self.assertEqual(
"Docker Error happened",
mock_create_container.call_args_list[0][0][1]['status_reason'])
