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_validate_container_state(self):
container = Container(self.context, **db_utils.get_test_container())
container.status = 'Stopped'
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'stop')
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'pause')
container.status = 'Running'
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'start')
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'unpause')
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'delete')
self.assertIsNone(utils.validate_container_state(
container, 'reboot'))
container.status = 'Stopped'
self.assertIsNone(utils.validate_container_state(
container, 'reboot'))
container.status = 'Running'
self.assertIsNone(utils.validate_container_state(
container, 'execute'))
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_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_wart_container_event(self, mock_finish, mock_start):
container = Container(self.context, **db_utils.get_test_container())
@utils.wrap_container_event(prefix='compute')
def fake_event(self, context, container):
pass
fake_event(self, self.context, container=container)
self.assertTrue(mock_start.called)
self.assertTrue(mock_finish.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 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_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)]
extra_spec = {}
self.assertRaises(exception.NoValidHost,
self.driver_cls().select_destinations, self.context,
containers, extra_spec)
def _test_get_container_any_type(self, container_type, container_cls):
fake_container = utils.get_test_container(
container_type=container_type)
uuid = fake_container['uuid']
with mock.patch.object(self.dbapi, 'get_container_by_uuid',
autospec=True) as mock_get_container:
mock_get_container.return_value = fake_container
container = objects.Container.get_container_any_type(
self.context, uuid)
mock_get_container.assert_called_once_with(
self.context, consts.TYPE_ANY, uuid)
self.assertEqual(self.context, container._context)
self.assertIsInstance(container, container_cls)
def test_wrap_container_event_log_exception(self, mock_finish, mock_start):
container = Container(self.context, **db_utils.get_test_container())
@utils.wrap_container_event(prefix='compute')
def fake_event(self, context, container):
raise exception.ZunException()
self.assertRaises(exception.ZunException, fake_event,
self, self.context, container=container)
self.assertTrue(mock_start.called)
self.assertTrue(mock_finish.called)
args, kwargs = mock_finish.call_args
self.assertIsInstance(kwargs['exc_val'], exception.ZunException)
def test_add_security_groups_to_ports(self, mock_neutron_api_cls):
addresses = {'fake-net-id': [{'port': 'fake-port-id'}]}
container = Container(self.context, **utils.get_test_container(
addresses=addresses))
mock_neutron_api_cls.return_value = self.network_api.neutron_api
old_port = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
security_group_ids = ['sg2']
self.network_api.add_security_groups_to_ports(container,
security_group_ids)
new_port = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
old_secgroups = old_port.pop('security_groups')
new_secgroups = new_port.pop('security_groups')
self.assertEqual(old_secgroups + ['sg2'], new_secgroups)
# assert nothing else changed besides security_groups
self.assertEqual(old_port, new_port)
def test_connect_container_to_network_failed(self, mock_neutron_api_cls):
container = Container(self.context, **utils.get_test_container())
network_name = 'c02afe4e-8350-4263-8078'
requested_net = {'ipv4_address': '10.5.0.22',
'port': 'fake-port-id',
'preserve_on_delete': True}
mock_neutron_api_cls.return_value = self.network_api.neutron_api
old_port = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', old_port['device_id'])
self.network_api.docker = mock.MagicMock()
self.network_api.docker.connect_container_to_network = \
mock.Mock(side_effect=exception.DockerError)
self.assertRaises(exception.DockerError,
self.network_api.connect_container_to_network,
container, network_name, requested_net)
new_port = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', new_port['device_id'])
def test_add_security_groups_to_ports_bad_update(
self, mock_neutron_api_cls):
addresses = {'fake-net-id': [{'port': 'fake-port-id'}]}
container = Container(self.context, **utils.get_test_container(
addresses=addresses))
mock_neutron_api_cls.return_value = self.network_api.neutron_api
security_group_ids = ['sg2']
with mock.patch.object(self.network_api.neutron_api,
'update_port') as mock_update_port:
mock_update_port.side_effect = n_exc.BadRequest(
message='error')
self.assertRaises(exception.SecurityGroupCannotBeApplied,
self.network_api.add_security_groups_to_ports,
container, security_group_ids)
mock_update_port.assert_called_once_with(
'fake-port-id',
{'port': {'security_groups': ['sg1', 'sg2']}},
admin=True)
def test_get_one_by_uuid(self, mock_container_get_by_uuid,
mock_capsule_get_by_uuid,
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
mock_container_show.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_get_by_uuid.return_value = test_capsule_obj
response = self.get('/v1/capsules/%s/' % test_capsule['uuid'])
context = mock_capsule_get_by_uuid.call_args[0][0]
self.assertIs(False, context.all_projects)
self.assertEqual(200, response.status_int)
self.assertEqual(test_capsule['uuid'],
response.json['uuid'])
def test_disconnect_container_from_network(self):
addresses = {'fake-net-id': [{'port': 'fake-port-id',
'preserve_on_delete': False}]}
container = Container(self.context, **utils.get_test_container(
addresses=addresses))
network_name = 'c02afe4e-8350-4263-8078'
ports = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports']
self.assertEqual(1, len(ports))
with mock.patch.object(self.network_api.docker,
'disconnect_container_from_network'
) as mock_disconnect:
self.network_api.disconnect_container_from_network(
container, network_name, 'fake-net-id')
mock_disconnect.assert_called_once_with(
container.container_id, network_name)
# assert the neutron port is deleted
ports = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports']
self.assertEqual(0, len(ports))
def test_select_destinations(self, mock_random_choice, mock_hosts_up):
all_hosts = ['host1', 'host2', 'host3', 'host4']
def _return_hosts(*args, **kwargs):
return all_hosts
mock_random_choice.side_effect = ['host3']
mock_hosts_up.side_effect = _return_hosts
test_container = utils.get_test_container()
containers = [objects.Container(self.context, **test_container)]
extra_spec = {}
dests = self.driver_cls().select_destinations(self.context, containers,
extra_spec)
self.assertEqual(1, len(dests))
(host, node) = (dests[0]['host'], dests[0]['nodename'])
self.assertEqual('host3', host)
self.assertIsNone(node)
calls = [mock.call(all_hosts)]
self.assertEqual(calls, mock_random_choice.call_args_list)
def test_connect_container_to_network(self):
container = Container(self.context, **utils.get_test_container())
network_name = 'c02afe4e-8350-4263-8078'
requested_net = {'ipv4_address': '10.5.0.22',
'port': 'fake-port-id',
'preserve_on_delete': True}
expected_address = [{'version': 4, 'addr': '10.5.0.22',
'port': 'fake-port-id',
'subnet_id': 'fake-subnet-id',
'preserve_on_delete': True}]
old_port = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', old_port['device_id'])
with mock.patch.object(self.network_api.docker,
'connect_container_to_network') as mock_connect:
address = self.network_api.connect_container_to_network(
container, network_name, requested_net)
self.assertEqual(expected_address, address)
mock_connect.assert_called_once_with(
container.container_id, network_name, ipv4_address='10.5.0.22')
new_port = self.network_api.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual(container.uuid, new_port['device_id'])
def test_container_network_detach(self, mock_detach):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.network_detach(self.context, container, 'network')
mock_detach.assert_called_once_with(self.context, container, mock.ANY)
def test_container_resize_failed(self, mock_resize):
container = Container(self.context, **utils.get_test_container())
mock_resize.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager.container_resize,
self.context, container, "100", "100")
def test_container_resize(self, mock_resize):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.container_resize(
self.context, container, "100", "100")
mock_resize.assert_called_once_with(
self.context, container, "100", "100")
def test_select_destinations(self, mock_random_choice, mock_list_by_binary,
mock_compute_list, mock_service_is_up):
all_services = [
FakeService('service1', 'host1'),
FakeService('service2', 'host2'),
FakeService('service3', 'host3'),
FakeService('service4', 'host4')
]
def _return_services(*args, **kwargs):
return all_services
self.driver.servicegroup_api.service_is_up = mock.Mock(
return_value=True)
mock_list_by_binary.side_effect = _return_services
numa_topology = {
"nodes": [{
"id": 0,
"cpuset": [1, 2, 3, 4],
"pinned_cpus": [],
"mem_total": 1024 * 64,
"mem_available": 1024 * 64
}, {
"id": 1,
"cpuset": [5, 6, 7, 8],
"pinned_cpus": [],
"mem_total": 1024 * 64,
"mem_available": 1024 * 64
}]
}
numa = objects.numa.NUMATopology._from_dict(numa_topology)
test_container = utils.get_test_container()
containers = [objects.Container(self.context, **test_container)]
node1 = objects.ComputeNode(self.context)
node1.cpus = 48
node1.cpu_used = 0.0
node1.mem_total = 1024 * 128
node1.mem_used = 1024 * 4
node1.mem_free = 1024 * 124
node1.mem_available = 1024 * 124
node1.disk_total = 80
node1.disk_used = 20
node1.hostname = 'host1'
node1.numa_topology = numa
node1.labels = {}
node1.pci_device_pools = None
node1.disk_quota_supported = True
node1.runtimes = ['runc']
node1.enable_cpu_pinning = False
node2 = objects.ComputeNode(self.context)
node2.cpus = 48
node2.cpu_used = 0.0
node2.mem_total = 1024 * 128
node2.mem_used = 1024 * 4
node2.mem_free = 1024 * 124
node2.mem_available = 1024 * 124
node2.disk_total = 80
node2.disk_used = 20
node2.hostname = 'host2'
node2.numa_topology = numa
node2.labels = {}
node2.pci_device_pools = None
node2.disk_quota_supported = True
node2.runtimes = ['runc']
node2.enable_cpu_pinning = False
node3 = objects.ComputeNode(self.context)
node3.cpus = 48
node3.cpu_used = 0.0
node3.mem_total = 1024 * 128
node3.mem_used = 1024 * 4
node3.mem_free = 1024 * 124
node3.mem_available = 1024 * 124
node3.disk_total = 80
node3.disk_used = 20
node3.hostname = 'host3'
node3.numa_topology = numa
node3.labels = {}
node3.pci_device_pools = None
node3.disk_quota_supported = True
node3.runtimes = ['runc']
node3.enable_cpu_pinning = False
node4 = objects.ComputeNode(self.context)
node4.cpus = 48
node4.cpu_used = 0.0
node4.mem_total = 1024 * 128
node4.mem_used = 1024 * 4
node4.mem_free = 1024 * 124
node4.mem_available = 1024 * 124
node4.disk_total = 80
node4.disk_used = 20
node4.hostname = 'host4'
node4.numa_topology = numa
node4.labels = {}
node4.pci_device_pools = None
node4.disk_quota_supported = True
node4.runtimes = ['runc']
node4.enable_cpu_pinning = False
nodes = [node1, node2, node3, node4]
mock_compute_list.return_value = nodes
def side_effect(hosts):
return hosts[2]
mock_random_choice.side_effect = side_effect
mock_service_is_up.return_value = True
extra_spec = {}
dests = self.driver.select_destinations(self.context, containers,
extra_spec)
self.assertEqual(1, len(dests))
(host, node) = (dests[0]['host'], dests[0]['nodename'])
self.assertEqual('host3', host)
self.assertIsNone(node)
def setUp(self):
super(TestContainerObject, self).setUp()
self.fake_container = utils.get_test_container()
def test_select_destinations(self, mock_random_choice, mock_list_by_binary,
mock_compute_list, mock_service_is_up):
all_services = [
FakeService('service1', 'host1'),
FakeService('service2', 'host2'),
FakeService('service3', 'host3'),
FakeService('service4', 'host4')
]
def _return_services(*args, **kwargs):
return all_services
self.driver.servicegroup_api.service_is_up = mock.Mock(
return_value=True)
mock_list_by_binary.side_effect = _return_services
test_container = utils.get_test_container()
containers = [objects.Container(self.context, **test_container)]
node1 = objects.ComputeNode(self.context)
node1.cpus = 48
node1.cpu_used = 0.0
node1.mem_total = 1024 * 128
node1.mem_used = 1024 * 4
node1.mem_free = 1024 * 124
node1.disk_total = 80
node1.disk_used = 20
node1.hostname = 'host1'
node1.numa_topology = None
node1.labels = {}
node1.pci_device_pools = None
node1.disk_quota_supported = True
node2 = objects.ComputeNode(self.context)
node2.cpus = 48
node2.cpu_used = 0.0
node2.mem_total = 1024 * 128
node2.mem_used = 1024 * 4
node2.mem_free = 1024 * 124
node2.disk_total = 80
node2.disk_used = 20
node2.hostname = 'host2'
node2.numa_topology = None
node2.labels = {}
node2.pci_device_pools = None
node2.disk_quota_supported = True
node3 = objects.ComputeNode(self.context)
node3.cpus = 48
node3.cpu_used = 0.0
node3.mem_total = 1024 * 128
node3.mem_used = 1024 * 4
node3.mem_free = 1024 * 124
node3.disk_total = 80
node3.disk_used = 20
node3.hostname = 'host3'
node3.numa_topology = None
node3.labels = {}
node3.pci_device_pools = None
node3.disk_quota_supported = True
node4 = objects.ComputeNode(self.context)
node4.cpus = 48
node4.cpu_used = 0.0
node4.mem_total = 1024 * 128
node4.mem_used = 1024 * 4
node4.mem_free = 1024 * 124
node4.disk_total = 80
node4.disk_used = 20
node4.hostname = 'host4'
node4.numa_topology = None
node4.labels = {}
node4.pci_device_pools = None
node4.disk_quota_supported = True
nodes = [node1, node2, node3, node4]
mock_compute_list.return_value = nodes
def side_effect(hosts):
return hosts[2]
mock_random_choice.side_effect = side_effect
mock_service_is_up.return_value = True
extra_spec = {}
dests = self.driver.select_destinations(self.context, containers,
extra_spec)
self.assertEqual(1, len(dests))
(host, node) = (dests[0]['host'], dests[0]['nodename'])
self.assertEqual('host3', host)
self.assertIsNone(node)
def test_heal_with_rebuilding_exception(self, mock_container_rebuild):
container = Container(self.context, **utils.get_test_container())
container.status = consts.RUNNING
mock_container_rebuild.side_effect = Exception
self.driver.heal_with_rebuilding_container(
self.context, container, mock.Mock())
def test_container_unpause(self, mock_unpause):
container = Container(self.context, **utils.get_test_container())
self.compute_manager._do_container_unpause(self.context, container)
mock_unpause.assert_called_once_with(self.context, container)
def test_container_start(self, mock_start, mock_save):
container = Container(self.context, **utils.get_test_container())
self.compute_manager._do_container_start(self.context, container)
mock_save.assert_called_with(self.context)
mock_start.assert_called_once_with(self.context, container)
def test_container_commit_failed(self, mock_commit):
container = Container(self.context, **utils.get_test_container())
mock_commit.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager._do_container_commit,
self.context, container, 'repo', 'tag')
def setUp(self):
super(TestContainerObject, self).setUp()
self.fake_cpuset = utils.get_cpuset_dict()
self.fake_container = utils.get_test_container(
cpuset=self.fake_cpuset, cpu_policy='dedicated')
self.fake_container.pop('capsule_id')
def setUp(self):
super(TestCapsuleObject, self).setUp()
self.fake_capsule = utils.get_test_container(
container_type=consts.TYPE_CAPSULE)
self.fake_capsule.pop('capsule_id')
def test_container_network_attach(self, mock_attach):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.network_attach(self.context, container, 'network')
def test_select_destinations(self, mock_random_choice, mock_list_by_binary,
mock_compute_list, mock_service_is_up):
all_services = [
FakeService('service1', 'host1'),
FakeService('service2', 'host2'),
FakeService('service3', 'host3'),
FakeService('service4', 'host4')
]
def _return_services(*args, **kwargs):
return all_services
self.driver.servicegroup_api.service_is_up = mock.Mock(
return_value=True)
mock_list_by_binary.side_effect = _return_services
numa_topology = {
"nodes": [{
"id": 0,
"cpuset": [1, 2, 3, 4],
"pinned_cpus": [],
"mem_total": 1024 * 64,
"mem_available": 1024 * 64
}, {
"id": 1,
"cpuset": [5, 6, 7, 8],
"pinned_cpus": [],
"mem_total": 1024 * 64,
"mem_available": 1024 * 64
}]
}
numa = objects.numa.NUMATopology._from_dict(numa_topology)
test_container = utils.get_test_container()
containers = [objects.Container(self.context, **test_container)]
node1 = objects.ComputeNode(self.context)
node1.rp_uuid = mock.sentinel.node1_rp_uuid
node1.updated_at = timeutils.utcnow()
node1.cpus = 48
node1.cpu_used = 0.0
node1.mem_total = 1024 * 128
node1.mem_used = 1024 * 4
node1.mem_free = 1024 * 124
node1.mem_available = 1024 * 124
node1.disk_total = 80
node1.disk_used = 20
node1.hostname = 'host1'
node1.numa_topology = numa
node1.labels = {}
node1.pci_device_pools = None
node1.disk_quota_supported = True
node1.runtimes = ['runc']
node1.enable_cpu_pinning = False
node2 = objects.ComputeNode(self.context)
node2.rp_uuid = mock.sentinel.node2_rp_uuid
node2.updated_at = timeutils.utcnow()
node2.cpus = 48
node2.cpu_used = 0.0
node2.mem_total = 1024 * 128
node2.mem_used = 1024 * 4
node2.mem_free = 1024 * 124
node2.mem_available = 1024 * 124
node2.disk_total = 80
node2.disk_used = 20
node2.hostname = 'host2'
node2.numa_topology = numa
node2.labels = {}
node2.pci_device_pools = None
node2.disk_quota_supported = True
node2.runtimes = ['runc']
node2.enable_cpu_pinning = False
node3 = objects.ComputeNode(self.context)
node3.rp_uuid = mock.sentinel.node3_rp_uuid
node3.updated_at = timeutils.utcnow()
node3.cpus = 48
node3.cpu_used = 0.0
node3.mem_total = 1024 * 128
node3.mem_used = 1024 * 4
node3.mem_free = 1024 * 124
node3.mem_available = 1024 * 124
node3.disk_total = 80
node3.disk_used = 20
node3.hostname = 'host3'
node3.numa_topology = numa
node3.labels = {}
node3.pci_device_pools = None
node3.disk_quota_supported = True
node3.runtimes = ['runc']
node3.enable_cpu_pinning = False
node4 = objects.ComputeNode(self.context)
node4.rp_uuid = mock.sentinel.node4_rp_uuid
node4.updated_at = timeutils.utcnow()
node4.cpus = 48
node4.cpu_used = 0.0
node4.mem_total = 1024 * 128
node4.mem_used = 1024 * 4
node4.mem_free = 1024 * 124
node4.mem_available = 1024 * 124
node4.disk_total = 80
node4.disk_used = 20
node4.hostname = 'host4'
node4.numa_topology = numa
node4.labels = {}
node4.pci_device_pools = None
node4.disk_quota_supported = True
node4.runtimes = ['runc']
node4.enable_cpu_pinning = False
nodes = [node1, node2, node3, node4]
mock_compute_list.return_value = nodes
mock_service_is_up.return_value = True
extra_spec = {}
mock_alloc_reqs_by_rp_uuid = {
node3.rp_uuid: [mock.sentinel.node3_alloc_req]
}
mock_provider_summaries = {node3.rp_uuid: {}}
dests = self.driver.select_destinations(
self.context, containers, extra_spec, mock_alloc_reqs_by_rp_uuid,
mock_provider_summaries, mock.sentinel.alloc_request_version)
self.assertEqual(1, len(dests))
(host, node) = (dests[0]['host'], dests[0]['nodename'])
self.assertEqual('host3', host)
self.assertIsNone(node)
container = containers[0]
self.mock_placement_client.claim_resources.assert_called_once_with(
mock.ANY,
container.uuid,
mock.sentinel.node3_alloc_req,
container.project_id,
container.user_id,
allocation_request_version=mock.sentinel.alloc_request_version,
consumer_generation=None)
def setUp(self):
super(TestContainerObject, self).setUp()
self.fake_cpuset = utils.get_cpuset_dict()
self.fake_container = utils.get_test_container(cpuset=self.fake_cpuset,
cpu_policy='dedicated')
self.fake_container.pop('capsule_id')
def test_add_security_groups_to_ports(self):
container = Container(self.context, **utils.get_test_container())
security_group_ids = ['1234567']
self.network_api.add_security_groups_to_ports(container,
security_group_ids)
def test_disconnect_container_from_network(self):
container = Container(self.context, **utils.get_test_container())
network_name = 'c02afe4e-8350-4263-8078'
self.network_api.disconnect_container_from_network(
container, network_name)
def test_container_update(self, mock_update, mock_save):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.container_update(self.context, container,
{'memory': 512})
mock_save.assert_called_with(self.context)
mock_update.assert_called_once_with(self.context, container)
def test_heal_with_rebuilding_exception(self, mock_container_rebuild):
container = Container(self.context, **utils.get_test_container())
container.status = consts.RUNNING
mock_container_rebuild.side_effect = Exception
self.driver.heal_with_rebuilding_container(self.context, container)
def test_container_attach_failed(self, mock_get_websocket_url):
container = Container(self.context, **utils.get_test_container())
mock_get_websocket_url.side_effect = Exception
self.assertRaises(exception.ZunException,
self.compute_manager.container_attach,
self.context, container)
def test_container_execute_failed(self, mock_execute_create):
container = Container(self.context, **utils.get_test_container())
mock_execute_create.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager.container_exec,
self.context, container, 'fake_cmd', True, False)
def setUp(self):
super(TestCapsuleObject, self).setUp()
self.fake_capsule = utils.get_test_container(
container_type=consts.TYPE_CAPSULE)
self.fake_capsule.pop('capsule_id')
def test_container_show(self, mock_show):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.container_show(self.context, container)
mock_show.assert_called_once_with(self.context, container)
def test_container_kill(self, mock_kill):
container = Container(self.context, **utils.get_test_container())
self.compute_manager._do_container_kill(self.context, container, None)
mock_kill.assert_called_once_with(self.context, container, None)
def test_container_show_failed(self, mock_show):
container = Container(self.context, **utils.get_test_container())
mock_show.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager.container_show,
self.context, container)
def test_container_logs_failed(self, mock_logs):
container = Container(self.context, **utils.get_test_container())
mock_logs.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager.container_logs, self.context,
container, True, True, False, 'all', None)
