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', }, ], })