class TestDockerDriver(base.DriverTestCase):
def setUp(self):
super(TestDockerDriver, self).setUp()
self.driver = DockerDriver()
dfc_patcher = mock.patch.object(docker_utils, 'docker_client')
docker_client = dfc_patcher.start()
self.dfc_context_manager = docker_client.return_value
self.mock_docker = mock.MagicMock()
self.mock_default_container = obj_utils.get_test_container(
self.context)
self.dfc_context_manager.__enter__.return_value = self.mock_docker
self.addCleanup(dfc_patcher.stop)
def test_inspect_image_path_is_none(self):
self.mock_docker.inspect_image = mock.Mock()
mock_image = mock.MagicMock()
self.driver.inspect_image(mock_image)
self.mock_docker.inspect_image.assert_called_once_with(mock_image)
def test_get_image(self):
self.mock_docker.get_image = mock.Mock()
self.driver.get_image(name='image_name')
self.mock_docker.get_image.assert_called_once_with('image_name')
def test_load_image(self):
self.mock_docker.load_image = mock.Mock()
mock_open_file = mock.mock_open()
with mock.patch('zun.container.docker.driver.open', mock_open_file):
self.driver.load_image('test')
self.mock_docker.load_image.assert_called_once_with(
mock_open_file.return_value)
def test_images(self):
self.mock_docker.images = mock.Mock()
self.driver.images(repo='test')
self.mock_docker.images.assert_called_once_with('test', False)
@mock.patch('zun.objects.container.Container.save')
def test_create_image_path_is_none(self, mock_save):
self.mock_docker.create_host_config = mock.Mock(
return_value={'Id1': 'val1', 'key2': 'val2'})
self.mock_docker.create_container = mock.Mock(
return_value={'Id': 'val1', 'key1': 'val2'})
image = {'path': ''}
mock_container = self.mock_default_container
result_container = self.driver.create(self.context, mock_container,
'test_sandbox', image)
host_config = {}
host_config['network_mode'] = 'container:test_sandbox'
host_config['ipc_mode'] = 'container:test_sandbox'
host_config['volumes_from'] = 'test_sandbox'
host_config['mem_limit'] = '512m'
host_config['cpu_quota'] = 100000
host_config['cpu_period'] = 100000
host_config['restart_policy'] = {'Name': 'no', 'MaximumRetryCount': 0}
self.mock_docker.create_host_config.assert_called_once_with(
**host_config)
kwargs = {
'name': 'zun-ea8e2a25-2901-438d-8157-de7ffd68d051',
'command': 'fake_command',
'environment': {'key1': 'val1', 'key2': 'val2'},
'working_dir': '/home/ubuntu',
'labels': {'key1': 'val1', 'key2': 'val2'},
'host_config': {'Id1': 'val1', 'key2': 'val2'},
'stdin_open': True,
'tty': True,
}
self.mock_docker.create_container.assert_called_once_with(
mock_container.image, **kwargs)
self.assertEqual('val1', result_container.container_id)
self.assertEqual(result_container.status,
consts.CREATED)
def test_delete_success(self):
self.mock_docker.remove_container = mock.Mock()
mock_container = mock.MagicMock()
self.driver.delete(mock_container, True)
self.mock_docker.remove_container.assert_called_once_with(
mock_container.container_id, force=True)
def test_delete_fail_no_result(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='404 Not Found') as mock_init:
self.mock_docker.remove_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.driver.delete(mock_container, True)
self.mock_docker.remove_container.assert_called_once_with(
mock_container.container_id, force=True)
self.assertEqual(1, mock_init.call_count)
def test_delete_fail_raise_error(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='test') as mock_init:
self.mock_docker.remove_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.assertRaises(errors.APIError, self.driver.delete,
mock_container,
True)
self.mock_docker.remove_container.assert_called_once_with(
mock_container.container_id, force=True)
self.assertEqual(1, mock_init.call_count)
def test_list(self):
self.mock_docker.list_containers.return_value = []
self.driver.list(self.context)
self.mock_docker.list_containers.assert_called_once_with()
@mock.patch('zun.objects.container.Container.save')
def test_update_containers_states(self, mock_save):
mock_container = obj_utils.get_test_container(
self.context, status='Running', host='host1')
mock_container_2 = obj_utils.get_test_container(
self.context, status='Stopped')
conf.CONF.set_override('host', 'host2')
with mock.patch.object(self.driver, 'list') as mock_list:
mock_list.return_value = [mock_container_2]
self.assertEqual(mock_container.host, 'host1')
self.assertEqual(mock_container.status, 'Running')
self.driver.update_containers_states(
self.context, [mock_container])
self.assertEqual(mock_container.host, 'host2')
self.assertEqual(mock_container.status, 'Stopped')
def test_show_success(self):
self.mock_docker.inspect_container = mock.Mock(
return_value={'State': 'running'})
mock_container = mock.MagicMock()
self.driver.show(self.context, mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
def test_show_fail_container_id_is_none(self):
mock_container = mock.MagicMock()
mock_container.container_id = None
result_container = self.driver.show(self.context, mock_container)
self.assertIsNone(result_container.container_id)
def test_show_fail_container_status_error(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='404 Not Found') as mock_init:
self.mock_docker.inspect_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
result_container = self.driver.show(self.context, mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
consts.ERROR)
self.assertEqual(2, mock_init.call_count)
def test_show_fail_api_error(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='test') as mock_init:
self.mock_docker.inspect_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.assertRaises(errors.APIError, self.driver.show,
self.context, mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
self.assertEqual(1, mock_init.call_count)
def test_reboot(self):
self.mock_docker.restart = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.reboot(
self.context, mock_container, '30')
self.mock_docker.restart.assert_called_once_with(
mock_container.container_id, timeout=30)
self.assertEqual(result_container.status,
consts.RUNNING)
def test_stop(self):
self.mock_docker.stop = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.stop(self.context, mock_container, '30')
self.mock_docker.stop.assert_called_once_with(
mock_container.container_id,
timeout=30)
self.assertEqual(result_container.status,
consts.STOPPED)
def test_start(self):
self.mock_docker.start = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.start(self.context, mock_container)
self.mock_docker.start.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
consts.RUNNING)
def test_pause(self):
self.mock_docker.pause = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.pause(self.context, mock_container)
self.mock_docker.pause.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
consts.PAUSED)
def test_unpause(self):
self.mock_docker.unpause = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.unpause(self.context, mock_container)
self.mock_docker.unpause.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
consts.RUNNING)
def test_show_logs(self):
self.mock_docker.logs = mock.Mock()
mock_container = mock.MagicMock()
self.driver.show_logs(self.context, mock_container)
self.mock_docker.logs.assert_called_once_with(
mock_container.container_id, True, True, False, False,
'all', None)
def test_execute_create(self):
self.mock_docker.exec_create = mock.Mock(return_value={'Id': 'test'})
mock_container = mock.MagicMock()
exec_id = self.driver.execute_create(
self.context, mock_container, 'ls')
self.assertEqual('test', exec_id)
self.mock_docker.exec_create.assert_called_once_with(
mock_container.container_id, 'ls', stdin=False, tty=False)
def test_execute_run(self):
self.mock_docker.exec_start = mock.Mock(return_value='test')
self.mock_docker.exec_inspect = mock.Mock(
return_value={u'ExitCode': 0})
self.driver.execute_run('test', 'ls')
self.mock_docker.exec_start.assert_called_once_with('test', False,
False, False)
self.mock_docker.exec_inspect.assert_called_once()
def test_kill_successful_signal_is_none(self):
self.mock_docker.kill = mock.Mock()
mock_container = mock.MagicMock()
self.driver.kill(self.context, mock_container, signal=None)
self.mock_docker.kill.assert_called_once_with(
mock_container.container_id)
def test_kill_successful_signal_is_not_none(self):
self.mock_docker.kill = mock.Mock()
mock_container = mock.MagicMock()
self.driver.kill(self.context, mock_container, signal='test')
self.mock_docker.kill.assert_called_once_with(
mock_container.container_id,
'test')
def test_resize(self):
self.mock_docker.resize = mock.Mock()
mock_container = mock.MagicMock()
self.driver.resize(self.context, mock_container, "100", "100")
self.mock_docker.resize.assert_called_once_with(
mock_container.container_id, 100, 100)
def test_commit(self):
self.mock_docker.commit = mock.Mock()
mock_container = mock.MagicMock()
self.driver.commit(self.context, mock_container, "repo", "tag")
self.mock_docker.commit.assert_called_once_with(
mock_container.container_id, "repo", "tag")
@mock.patch('zun.network.kuryr_network.KuryrNetwork'
'.connect_container_to_network')
@mock.patch('zun.container.docker.driver.DockerDriver.get_sandbox_name')
@mock.patch(
'zun.container.docker.driver.DockerDriver._get_security_group_ids')
def test_create_sandbox(self, mock_get_security_group_ids,
mock_get_sandbox_name, mock_connect):
sandbox_name = 'my_test_sandbox'
mock_get_sandbox_name.return_value = sandbox_name
self.mock_docker.create_container = mock.Mock(
return_value={'Id': 'val1', 'key1': 'val2'})
mock_container = mock.MagicMock()
requested_networks = []
with mock.patch.object(self.driver, '_get_available_network'):
result_sandbox_id = self.driver.create_sandbox(
self.context, mock_container, 'kubernetes/pause',
requested_networks=requested_networks)
self.mock_docker.create_container.assert_called_once_with(
'kubernetes/pause', name=sandbox_name, hostname=sandbox_name)
self.assertEqual(result_sandbox_id, 'val1')
@mock.patch('zun.network.kuryr_network.KuryrNetwork'
'.connect_container_to_network')
@mock.patch('zun.container.docker.driver.DockerDriver.get_sandbox_name')
@mock.patch(
'zun.container.docker.driver.DockerDriver._get_security_group_ids')
def test_create_sandbox_with_long_name(self, mock_get_security_group_ids,
mock_get_sandbox_name,
mock_connect):
sandbox_name = 'x' * 100
mock_get_sandbox_name.return_value = sandbox_name
self.mock_docker.create_container = mock.Mock(
return_value={'Id': 'val1', 'key1': 'val2'})
mock_container = mock.MagicMock()
with mock.patch.object(self.driver, '_get_available_network'):
requested_networks = []
result_sandbox_id = self.driver.create_sandbox(
self.context, mock_container, 'kubernetes/pause',
requested_networks=requested_networks)
self.mock_docker.create_container.assert_called_once_with(
'kubernetes/pause', name=sandbox_name, hostname=sandbox_name[:63])
self.assertEqual(result_sandbox_id, 'val1')
def test_delete_sandbox(self):
self.mock_docker.remove_container = mock.Mock()
mock_container = mock.MagicMock()
self.driver.delete_sandbox(self.context, mock_container,
sandbox_id='test_sandbox_id')
self.mock_docker.remove_container.assert_called_once_with(
'test_sandbox_id', force=True)
def test_stop_sandbox(self):
self.mock_docker.stop = mock.Mock()
self.driver.stop_sandbox(context=self.context,
sandbox_id='test_sandbox_id')
self.mock_docker.stop.assert_called_once_with('test_sandbox_id')
def test_get_sandbox_none_id(self):
mock_container = mock.MagicMock()
mock_container.meta = None
result_sandbox_id = self.driver.get_sandbox_id(mock_container)
self.assertIsNone(result_sandbox_id)
def test_get_sandbox_not_none_id(self):
mock_container = mock.MagicMock()
result_sandbox_id = self.driver.get_sandbox_id(mock_container)
self.assertEqual(result_sandbox_id,
mock_container.meta.get('sandbox_id', None))
def test_set_sandbox_id(self):
mock_container = mock.MagicMock(meta={'sandbox_id': 'test_sandbox_id'})
self.driver.set_sandbox_id(mock_container, 'test_sandbox_id')
self.assertEqual(mock_container.meta['sandbox_id'],
'test_sandbox_id')
def test_get_sandbox_name(self):
mock_container = mock.MagicMock(
uuid='ea8e2a25-2901-438d-8157-de7ffd68d051')
result_sanbox_name = self.driver.get_sandbox_name(mock_container)
self.assertEqual(result_sanbox_name,
'zun-sandbox-ea8e2a25-2901-438d-8157-de7ffd68d051')
def test_get_container_name(self):
mock_container = mock.MagicMock(
uuid='ea8e2a25-2901-438d-8157-de7ffd68d051')
result_container_name = self.driver.get_container_name(
mock_container)
self.assertEqual(result_container_name,
'zun-ea8e2a25-2901-438d-8157-de7ffd68d051')
def test_execute_resize(self):
self.mock_docker.exec_resize = mock.Mock()
fake_exec_id = 'fake_id'
self.driver.execute_resize(fake_exec_id, "100", "100")
self.mock_docker.exec_resize.assert_called_once_with(
fake_exec_id, height=100, width=100)
def test_get_host_info(self):
self.mock_docker.info = mock.Mock()
self.mock_docker.info.return_value = {'Containers': 10,
'ContainersPaused': 0,
'ContainersRunning': 8,
'ContainersStopped': 2,
'NCPU': 48,
'Architecture': 'x86_64',
'OSType': 'linux',
'OperatingSystem': 'CentOS',
'KernelVersion': '3.10.0-123',
'Labels': ['dev.type=product']}
(total, running, paused, stopped, cpus, architecture,
os_type, os, kernel_version, labels) = self.driver.get_host_info()
self.assertEqual(10, total)
self.assertEqual(8, running)
self.assertEqual(0, paused)
self.assertEqual(2, stopped)
self.assertEqual(48, cpus)
self.assertEqual('x86_64', architecture)
self.assertEqual('linux', os_type)
self.assertEqual('CentOS', os)
self.assertEqual('3.10.0-123', kernel_version)
self.assertEqual({"dev.type": "product"}, labels)
def test_get_cpu_used(self):
self.mock_docker.containers = mock.Mock()
self.mock_docker.containers.return_value = [{'Id': '123456'}]
self.mock_docker.inspect_container = mock.Mock()
self.mock_docker.inspect_container.return_value = {
'HostConfig': {'NanoCpus': 1.0 * 1e9,
'CpuPeriod': 0,
'CpuQuota': 0}}
cpu_used = self.driver.get_cpu_used()
self.assertEqual(1.0, cpu_used)
def test_stats(self):
self.mock_docker.stats = mock.Mock()
mock_container = mock.MagicMock()
self.mock_docker.stats.return_value = {
'cpu_stats': {'cpu_usage': {'usage_in_usermode': 1000000000,
'total_usage': 1000000000},
'system_cpu_usage': 1000000000000},
'blkio_stats': {'io_service_bytes_recursive':
[{'major': 253, 'value': 10000000,
'minor': 4, 'op': 'Read'},
{'major': 253, 'value': 0,
'minor': 4, 'op': 'Write'},
{'major': 253, 'value': 0,
'minor': 4, 'op': 'Sync'},
{'major': 253, 'value': 10000000,
'minor': 4, 'op': 'Async'},
{'major': 253, 'value': 10000000,
'minor': 4, 'op': 'Total'}]},
'memory_stats': {'usage': 104857600,
'limit': 1048576000},
'networks': {'eth0':
{'tx_dropped': 0, 'rx_packets': 2, 'rx_bytes': 200,
'tx_errors': 0, 'rx_errors': 0, 'tx_bytes': 200,
'rx_dropped': 0, 'tx_packets': 2}}}
stats_info = self.driver.stats(self.context, mock_container)
self.assertEqual(0.1, stats_info['CPU %'])
self.assertEqual(100, stats_info['MEM USAGE(MiB)'])
self.assertEqual(1000, stats_info['MEM LIMIT(MiB)'])
self.assertEqual(10, stats_info['MEM %'])
self.assertEqual('10000000/0', stats_info['BLOCK I/O(B)'])
self.assertEqual('200/200', stats_info['NET I/O(B)'])
class TestDockerDriver(base.DriverTestCase):
def setUp(self):
super(TestDockerDriver, self).setUp()
self.driver = DockerDriver()
dfc_patcher = mock.patch.object(docker_utils, 'docker_client')
docker_client = dfc_patcher.start()
self.dfc_context_manager = docker_client.return_value
self.mock_docker = mock.MagicMock()
container_dict = db_utils.create_test_container(context=self.context)
self.mock_default_container = mock.MagicMock(**container_dict)
self.dfc_context_manager.__enter__.return_value = self.mock_docker
self.addCleanup(dfc_patcher.stop)
def test_inspect_image_path_is_none(self):
self.mock_docker.inspect_image = mock.Mock()
mock_image = mock.MagicMock()
self.driver.inspect_image(mock_image)
self.mock_docker.inspect_image.assert_called_once_with(mock_image)
def test_inspect_image_path_is_not_none(self):
self.mock_docker.load_image = mock.Mock()
self.mock_docker.inspect_image = mock.Mock()
mock_open_file = mock.mock_open(read_data='test_data')
with mock.patch('zun.container.docker.driver.open', mock_open_file):
mock_image = mock.MagicMock()
self.driver.inspect_image(mock_image, 'test')
self.mock_docker.load_image.assert_called_once_with('test_data')
self.mock_docker.inspect_image.assert_called_once_with(mock_image)
def test_images(self):
self.mock_docker.images = mock.Mock()
self.driver.images(repo='test')
self.mock_docker.images.assert_called_once_with('test', False)
@mock.patch('zun.objects.container.Container.save')
def test_create_image_path_is_none(self, mock_save):
self.mock_docker.create_host_config = mock.Mock(return_value={
'Id1': 'val1',
'key2': 'val2'
})
self.mock_docker.create_container = mock.Mock(return_value={
'Id': 'val1',
'key1': 'val2'
})
image = {'path': ''}
mock_container = self.mock_default_container
result_container = self.driver.create(self.context, mock_container,
'test_sandbox', image)
host_config = {}
host_config['network_mode'] = 'container:test_sandbox'
host_config['ipc_mode'] = 'container:test_sandbox'
host_config['volumes_from'] = 'test_sandbox'
host_config['mem_limit'] = '512m'
host_config['cpu_quota'] = 100000
host_config['cpu_period'] = 100000
self.mock_docker.create_host_config.assert_called_once_with(
**host_config)
kwargs = {
'name': 'zun-ea8e2a25-2901-438d-8157-de7ffd68d051',
'command': 'fake_command',
'environment': {
'key1': 'val1',
'key2': 'val2'
},
'working_dir': '/home/ubuntu',
'labels': {
'key1': 'val1',
'key2': 'val2'
},
'host_config': {
'Id1': 'val1',
'key2': 'val2'
},
}
self.mock_docker.create_container.assert_called_once_with(
mock_container.image, **kwargs)
self.assertEqual(result_container.container_id, 'val1')
self.assertEqual(result_container.status,
fields.ContainerStatus.STOPPED)
@mock.patch('zun.objects.container.Container.save')
def test_create_image_path_is_not_none(self, mock_save):
self.mock_docker.load_image = mock.Mock(return_value='load_test')
self.mock_docker.create_host_config = mock.Mock(return_value={
'Id1': 'val1',
'key2': 'val2'
})
self.mock_docker.create_container = mock.Mock(return_value={
'Id': 'val1',
'key1': 'val2'
})
mock_open_file = mock.mock_open(read_data='test_data')
with mock.patch('zun.container.docker.driver.open', mock_open_file):
mock_container = self.mock_default_container
result_container = self.driver.create(self.context, mock_container,
'test_sandbox',
{'path': 'test_path'})
self.mock_docker.load_image.assert_called_once_with('test_data')
host_config = {}
host_config['network_mode'] = 'container:test_sandbox'
host_config['ipc_mode'] = 'container:test_sandbox'
host_config['volumes_from'] = 'test_sandbox'
host_config['mem_limit'] = '512m'
host_config['cpu_quota'] = 100000
host_config['cpu_period'] = 100000
self.mock_docker.create_host_config.assert_called_once_with(
**host_config)
kwargs = {
'command': 'fake_command',
'environment': {
'key1': 'val1',
'key2': 'val2'
},
'working_dir': '/home/ubuntu',
'labels': {
'key1': 'val1',
'key2': 'val2'
},
'host_config': {
'Id1': 'val1',
'key2': 'val2'
},
'name': 'zun-ea8e2a25-2901-438d-8157-de7ffd68d051',
}
self.mock_docker.create_container.assert_called_once_with(
mock_container.image, **kwargs)
self.assertEqual(result_container.container_id, 'val1')
self.assertEqual(result_container.status,
fields.ContainerStatus.STOPPED)
def test_delete_success(self):
self.mock_docker.remove_container = mock.Mock()
mock_container = mock.MagicMock()
self.driver.delete(mock_container, True)
self.mock_docker.remove_container.assert_called_once_with(
mock_container.container_id, force=True)
def test_delete_fail_no_result(self):
with mock.patch.object(errors.APIError,
'__str__',
return_value='404 Not Found') as mock_init:
self.mock_docker.remove_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.driver.delete(mock_container, True)
self.mock_docker.remove_container.assert_called_once_with(
mock_container.container_id, force=True)
self.assertEqual(1, mock_init.call_count)
def test_delete_fail_raise_error(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='test') as mock_init:
self.mock_docker.remove_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.assertRaises(errors.APIError, self.driver.delete,
mock_container, True)
self.mock_docker.remove_container.assert_called_once_with(
mock_container.container_id, force=True)
self.assertEqual(1, mock_init.call_count)
def test_list(self):
self.mock_docker.list_instances = mock.Mock()
self.driver.list()
self.mock_docker.list_instances.assert_called_once_with()
def test_show_success(self):
self.mock_docker.inspect_container = mock.Mock(return_value={})
mock_container = mock.MagicMock()
self.driver.show(mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
def test_show_fail_container_id_is_none(self):
mock_container = mock.MagicMock()
mock_container.container_id = None
result_container = self.driver.show(mock_container)
self.assertIsNone(result_container.container_id)
def test_show_fail_container_status_error(self):
with mock.patch.object(errors.APIError,
'__str__',
return_value='404 Not Found') as mock_init:
self.mock_docker.inspect_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
result_container = self.driver.show(mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
fields.ContainerStatus.ERROR)
self.assertEqual(1, mock_init.call_count)
def test_show_fail_api_error(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='test') as mock_init:
self.mock_docker.inspect_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.assertRaises(errors.APIError, self.driver.show,
mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
self.assertEqual(1, mock_init.call_count)
def test_reboot(self):
self.mock_docker.restart = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.reboot(mock_container, '30')
self.mock_docker.restart.assert_called_once_with(
mock_container.container_id, timeout=30)
self.assertEqual(result_container.status,
fields.ContainerStatus.RUNNING)
def test_stop(self):
self.mock_docker.stop = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.stop(mock_container, '30')
self.mock_docker.stop.assert_called_once_with(
mock_container.container_id, timeout=30)
self.assertEqual(result_container.status,
fields.ContainerStatus.STOPPED)
def test_start(self):
self.mock_docker.start = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.start(mock_container)
self.mock_docker.start.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
fields.ContainerStatus.RUNNING)
def test_pause(self):
self.mock_docker.pause = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.pause(mock_container)
self.mock_docker.pause.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
fields.ContainerStatus.PAUSED)
def test_unpause(self):
self.mock_docker.unpause = mock.Mock()
mock_container = mock.MagicMock()
result_container = self.driver.unpause(mock_container)
self.mock_docker.unpause.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
fields.ContainerStatus.RUNNING)
def test_show_logs(self):
self.mock_docker.get_container_logs = mock.Mock()
mock_container = mock.MagicMock()
self.driver.show_logs(mock_container)
self.mock_docker.get_container_logs.assert_called_once_with(
mock_container.container_id)
def test_execute(self):
self.mock_docker.exec_create = mock.Mock(return_value='test')
self.mock_docker.exec_start = mock.Mock(return_value='test')
mock_container = mock.MagicMock()
self.driver.execute(mock_container, 'ls')
self.mock_docker.exec_create.assert_called_once_with(
mock_container.container_id, 'ls', True, True, False)
self.mock_docker.exec_start.assert_called_once_with(
'test', False, False, False)
def test_kill_successful_signal_is_none(self):
self.mock_docker.kill = mock.Mock()
self.mock_docker.inspect_container = mock.Mock(return_value={})
mock_container = mock.MagicMock()
self.driver.kill(mock_container, signal=None)
self.mock_docker.kill.assert_called_once_with(
mock_container.container_id)
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
def test_kill_successful_signal_is_not_none(self):
self.mock_docker.kill = mock.Mock()
self.mock_docker.inspect_container = mock.Mock(return_value={})
mock_container = mock.MagicMock()
self.driver.kill(mock_container, signal='test')
self.mock_docker.kill.assert_called_once_with(
mock_container.container_id, 'test')
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
def test_kill_fail_container_status_error(self):
with mock.patch.object(errors.APIError,
'__str__',
return_value='404 Not Found') as mock_init:
self.mock_docker.kill = mock.Mock()
self.mock_docker.inspect_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
result_container = self.driver.kill(mock_container, signal='test')
self.mock_docker.kill.assert_called_once_with(
mock_container.container_id, 'test')
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
self.assertEqual(result_container.status,
fields.ContainerStatus.ERROR)
self.assertEqual(1, mock_init.call_count)
def test_kill_fail_api_error(self):
with mock.patch.object(errors.APIError, '__str__',
return_value='test') as mock_init:
self.mock_docker.kill = mock.Mock()
self.mock_docker.inspect_container = mock.Mock(
side_effect=errors.APIError('Error', '', ''))
mock_container = mock.MagicMock()
self.assertRaises(errors.APIError, self.driver.kill,
mock_container, 'test')
self.mock_docker.kill.assert_called_once_with(
mock_container.container_id, 'test')
self.mock_docker.inspect_container.assert_called_once_with(
mock_container.container_id)
self.assertEqual(1, mock_init.call_count)
@mock.patch('zun.container.docker.driver.DockerDriver.get_sandbox_name')
def test_create_sandbox(self, mock_get_sandbox_name):
sandbox_name = 'my_test_sandbox'
mock_get_sandbox_name.return_value = sandbox_name
self.mock_docker.create_container = mock.Mock(return_value={
'Id': 'val1',
'key1': 'val2'
})
self.mock_docker.start()
mock_container = mock.MagicMock()
result_sandbox_id = self.driver.create_sandbox(self.context,
mock_container,
'kubernetes/pause')
self.mock_docker.create_container.assert_called_once_with(
'kubernetes/pause', name=sandbox_name, hostname=sandbox_name)
self.assertEqual(result_sandbox_id, 'val1')
@mock.patch('zun.container.docker.driver.DockerDriver.get_sandbox_name')
def test_create_sandbox_with_long_name(self, mock_get_sandbox_name):
sandbox_name = 'x' * 100
mock_get_sandbox_name.return_value = sandbox_name
self.mock_docker.create_container = mock.Mock(return_value={
'Id': 'val1',
'key1': 'val2'
})
self.mock_docker.start()
mock_container = mock.MagicMock()
result_sandbox_id = self.driver.create_sandbox(self.context,
mock_container,
'kubernetes/pause')
self.mock_docker.create_container.assert_called_once_with(
'kubernetes/pause', name=sandbox_name, hostname=sandbox_name[:63])
self.assertEqual(result_sandbox_id, 'val1')
def test_delete_sandbox(self):
self.mock_docker.remove_container = mock.Mock()
self.driver.delete_sandbox(context=self.context,
sandbox_id='test_sandbox_id')
self.mock_docker.remove_container.assert_called_once_with(
'test_sandbox_id', force=True)
def test_stop_sandbox(self):
self.mock_docker.stop = mock.Mock()
self.driver.stop_sandbox(context=self.context,
sandbox_id='test_sandbox_id')
self.mock_docker.stop.assert_called_once_with('test_sandbox_id')
def test_get_sandbox_none_id(self):
mock_container = mock.MagicMock()
mock_container.meta = None
result_sandbox_id = self.driver.get_sandbox_id(mock_container)
self.assertIsNone(result_sandbox_id)
def test_get_sandbox_not_none_id(self):
mock_container = mock.MagicMock()
result_sandbox_id = self.driver.get_sandbox_id(mock_container)
self.assertEqual(result_sandbox_id,
mock_container.meta.get('sandbox_id', None))
def test_set_sandbox_id(self):
mock_container = mock.MagicMock(meta={'sandbox_id': 'test_sandbox_id'})
self.driver.set_sandbox_id(mock_container, 'test_sandbox_id')
self.assertEqual(mock_container.meta['sandbox_id'], 'test_sandbox_id')
def test_get_sandbox_name(self):
mock_container = mock.MagicMock(
uuid='ea8e2a25-2901-438d-8157-de7ffd68d051')
result_sanbox_name = self.driver.get_sandbox_name(mock_container)
self.assertEqual(result_sanbox_name,
'zun-sandbox-ea8e2a25-2901-438d-8157-de7ffd68d051')
def test_get_container_name(self):
mock_container = mock.MagicMock(
uuid='ea8e2a25-2901-438d-8157-de7ffd68d051')
result_container_name = self.driver.get_container_name(mock_container)
self.assertEqual(result_container_name,
'zun-ea8e2a25-2901-438d-8157-de7ffd68d051')
@mock.patch('zun.container.docker.driver.DockerDriver.get_sandbox_id')
def test_get_addresses(self, mock_get_sandbox_id):
mock_get_sandbox_id.return_value = 'test_sandbox_id'
self.mock_docker.inspect_container = mock.Mock(
return_value={'NetworkSettings': {
'IPAddress': '127.0.0.1'
}})
mock_container = mock.MagicMock()
result_addresses = self.driver.get_addresses(self.context,
mock_container)
self.mock_docker.inspect_container.assert_called_once_with(
'test_sandbox_id')
self.assertEqual(result_addresses, {
'default': [
{
'addr': '127.0.0.1',
},
],
})