def test_create_error_from_exception(self): resp = requests.Response() resp.status_code = 500 err = APIError('') try: resp.raise_for_status() except requests.exceptions.HTTPError as e: try: create_api_error_from_http_exception(e) except APIError as e: err = e assert err.is_server_error() is True
def test_node_start_remove_container_error( self, m_docker_client, m_client, m_install_kube, m_warn_if_hostname_conflict, m_warn_if_unknown_ip, m_get_host_ips, m_check_system, m_os_makedirs, m_os_path_exists): """ Test that the docker client raises an APIError when it fails to remove a container. """ # Set up mock objects err = APIError("Test error message", Response()) m_docker_client.remove_container.side_effect = err # Set up arguments node_image = 'node_image' log_dir = './log_dir' ip = '' ip6 = 'aa:bb::zz' as_num = '' detach = False kubernetes = True libnetwork = False # Testing expecting APIError exception self.assertRaises(APIError, node.node_start, node_image, log_dir, ip, ip6, as_num, detach, kubernetes, libnetwork)
def test_api_error_version_other(self, mock_logging): msg = b"Something broke!" with pytest.raises(errors.ConnectionError): with handle_connection_errors(mock.Mock(api_version='1.22')): raise APIError(None, None, msg) mock_logging.error.assert_called_once_with(msg)
def test_409_exc_handling(client, img, resp): """ Verify docker client 409 exception handling """ client.images.remove.side_effect = APIError("Mock 409 exception", response=resp) nuke() assert client.images.remove.called
def test_node_start_remove_container_error( self, m_docker_client, m_client, m_install_plugin, m_error_if_bgp_ip_conflict, m_warn_if_hostname_conflict, m_warn_if_unknown_ip, m_get_host_ips, m_setup_ip, m_check_system, m_os_makedirs, m_os_path_exists): """ Test that the docker client raises an APIError when it fails to remove a container. """ # Set up mock objects err = APIError("Test error message", Response()) m_docker_client.remove_container.side_effect = err m_check_system.return_value = [True, True, True] # Set up arguments node_image = 'node_image' runtime = 'docker' log_dir = './log_dir' ip = '' ip6 = 'aa:bb::zz' as_num = '' detach = False kube_plugin_version = 'v0.2.1' rkt = False libnetwork = False # Testing expecting APIError exception self.assertRaises(APIError, node.node_start, node_image, runtime, log_dir, ip, ip6, as_num, detach, kube_plugin_version, rkt, libnetwork)
def test_api_error(self, docker_run: Mock): """Test proper handling of container encountering an error""" docker_run.side_effect = APIError("test error") rpm = ReductionProcessManager(self.message, self.run_name, self.software) self.assertRaises(APIError, rpm.run) docker_run.assert_called_once()
def delete(self, remove_volumes=False, links=False, force=False): """ """ response = None if self.state()["running"]: self.stop() logger.info('is being deleted.', extra={ 'formatter': 'container', 'container': self.name }) try: response = self.client.remove_container(self.id, remove_volumes, links, force) except APIError as e: if e.response.status_code == 404: logger.info('is unable to located.', extra={ 'formatter': 'container', 'container': self.name }) else: raise APIError("Docker Error: {0}".format(e.explanation), e.response) return response
def test_api_error_version_mismatch(self, mock_logging): with pytest.raises(errors.ConnectionError): with handle_connection_errors(mock.Mock(api_version='1.22')): raise APIError(None, None, b"client is newer than server") _, args, _ = mock_logging.error.mock_calls[0] assert "Docker Engine of version 1.10.0 or greater" in args[0]
def pull_image(self, image, tag, stream=False): if stream: return self.client.pull(image, tag, auth_config=self.auth_config, stream=True) rst = self.client.pull(image, tag, auth_config=self.auth_config) last_message = json.loads(rst.split('\r\n')[-2]) if last_message.get('error'): raise APIError(last_message['error'])
def test_node_start_remove_container_error(self, m_root, m_docker, m_docker_client, m_client, m_call, m_conntrack, m_setup_ip, m_check_system, m_os_makedirs, m_os_path_exists, m_ipv6_enabled): """ Test that the docker client raises an APIError when it fails to remove a container. """ # Set up mock objects m_root.return_value = False err = APIError("Test error message", Response()) m_docker_client.remove_container.side_effect = err m_check_system.return_value = [True, True, True] # Set up arguments node_image = 'node_image' runtime = 'docker' log_dir = './log_dir' ip = '' ip6 = 'aa:bb::zz' as_num = '' detach = False libnetwork = False no_pull = False # Testing expecting APIError exception self.assertRaises(APIError, node.node_start, node_image, runtime, log_dir, ip, ip6, as_num, detach, libnetwork, no_pull)
def my_func(*args, **kwargs): my_args = ('some', 'new') my_kwargs = {'one': 'first', 'two': 'second'} assert args == my_args assert kwargs == my_kwargs response = requests.Response() response.status_code = 408 raise APIError("test fail", response)
def test_check_and_pull_remote_true(mock_get_local, mock_check_for_updates, mock_get_remote, mock_pull, docker_image): mock_get_local.side_effect = APIError("Fail") docker_image._check_and_pull("kathara/test", True) mock_get_local.assert_called_once_with("kathara/test") assert not mock_check_for_updates.called mock_get_remote.assert_called_once_with("kathara/test") mock_pull.assert_called_once_with("kathara/test")
def test_apierror_str(self): """ A string representation can be constructed of an ``APIError`` constructed with the response returned by ``make_response``. """ self.assertEqual( str(APIError("", make_response(500, "Simulated server error"))), "500 Server Error: Simulated server error", )
def test_must_raise_if_image_not_found(self): msg = "some error" self.mock_docker_client.api.pull.side_effect = APIError(msg) with self.assertRaises(DockerImagePullFailedException) as context: self.manager.pull_image("imagename") ex = context.exception self.assertEqual(str(ex), msg)
def test_remove_image_with_error(self): self.mock_client.remove_image.side_effect = error = APIError( message="testing", response={}, explanation="Boom") web = Service('web', image='example', client=self.mock_client) with mock.patch('compose.service.log', autospec=True) as mock_log: assert not web.remove_image(ImageType.all) mock_log.error.assert_called_once_with( "Failed to remove image for service %s: %s", web.name, error)
def test_container_running_err(self, m_docker_client): """ Test the _container_running command when the inspect command errors. """ response = Response() response.status_code = 400 m_docker_client.inspect_container.side_effect = APIError("Test error message", response) self.assertRaises(APIError, node._container_running, "container1") m_docker_client.inspect_container.assert_called_once_with("container1")
def test_container_attach_event(self, thread_map, mock_presenters): container_id = 'abcd' mock_container = mock.Mock(is_restarting=False) mock_container.attach_log_stream.side_effect = APIError("race condition") event_die = {'action': 'die', 'id': container_id} event_start = {'action': 'start', 'id': container_id, 'container': mock_container} event_stream = [event_die, event_start] thread_args = 'foo', 'bar' watch_events(thread_map, event_stream, mock_presenters, thread_args) assert mock_container.attach_log_stream.called
def _findlayer(self, image_id): if image_id.lower() in self.layers_by_id: return self.layers_by_id[image_id] if image_id in self.layers_by_tag: return self.layers_by_tag[image_id] raise APIError(HTTPError('404 Client Error: Not Found'), None, explanation='No such image: {}'.format(image_id))
def test_410_exc_handling_and_raising(client, img, resp): """ Verify docker client 410 exception re-raising """ resp.status_code = 410 client.images.remove.side_effect = APIError("Mock 410 exception", response=resp) with pytest.raises(APIError) as exc: nuke() assert client.images.remove.called assert '410' in str(exc.value)
def test__docker_inspect_error_not_found(self, m_client): # Mock container_id = "12345" response = MagicMock() response.status_code = 404 explanation = "explanation" m_client().inspect_container.side_effect = APIError(1, response, explanation) # Call assert_raises(KeyError, self.engine._docker_inspect, container_id)
def test_container_running_no_cont(self, m_docker_client): """ Test the _container_running command when no container exists. """ response = Response() response.status_code = 404 m_docker_client.inspect_container.side_effect = APIError("Test error message", response) self.assertEquals(node._container_running("container1"), False) m_docker_client.inspect_container.assert_called_once_with("container1")
def test_node_stop_error(self, m_docker_client, m_client): """ Test node_stop raises an exception when the docker client cannot not stop the node """ # Set up mock objects err = APIError("Test error message", Response()) m_docker_client.stop.side_effect = err # Call method under test expecting an exception self.assertRaises(APIError, node.node_stop, True)
def test_must_raise_unknown_docker_api_errors(self): self.container.is_created.return_value = True real_container_mock = Mock() self.mock_docker_client.containers.get.return_value = real_container_mock real_container_mock.remove = Mock() real_container_mock.remove.side_effect = APIError("some error") with self.assertRaises(APIError): self.container.delete() # Must *NOT* reset ID because Docker API raised an exception self.assertIsNotNone(self.container.id)
def test_must_raise_unknown_docker_api_errors(self): self.container.is_created.return_value = True real_container_mock = Mock() self.mock_docker_client.containers.get.return_value = real_container_mock real_container_mock.stop = Mock() real_container_mock.stop.side_effect = APIError("some error") with self.assertRaises(APIError): self.container.stop() # Ensure ID remains set self.assertIsNotNone(self.container.id)
def test_node_stop_error(self, m_docker_client, m_client): """ Test node_stop raises an exception when the docker client cannot not stop the node """ # Set up mock objects m_client.get_endpoints.return_value = [Mock()] err = APIError("Test error message", Response()) for sidee in ([None, err], [err, None]): m_docker_client.stop.side_effect = sidee # Call method under test expecting an exception self.assertRaises(APIError, node.node_stop, True)
def test_must_work_if_container_delete_is_in_progress(self): self.container.is_created.return_value = True real_container_mock = Mock() self.mock_docker_client.containers.get.return_value = real_container_mock real_container_mock.remove = Mock() real_container_mock.remove.side_effect = APIError("removal of container is already in progress") self.container.delete() self.mock_docker_client.containers.get.assert_called_with("someid") real_container_mock.remove.assert_called_with(force=True) # Must reset ID to None because container is now gone self.assertIsNone(self.container.id)
def test_clean_docker_error(self, check_docker, volumes, q): volume1 = MagicMock() volume1.name = "some-name-tmpvol" volume1.remove.side_effect = APIError("Testing") volumes.list.return_value = [volume1] question = MagicMock(name="pop-the-question") question.ask.return_value = True q.confirm.return_value = question runner = CliRunner() result = runner.invoke(cli_node_clean) # check exit code self.assertEqual(result.exit_code, 1)
def add(self, unit_name, image_name, ports=frozenset(), environment=None, volumes=frozenset(), mem_limit=None, cpu_shares=None, restart_policy=RestartNever(), command_line=None, swappiness=0): if unit_name in self._units: return fail(AlreadyExists(unit_name)) for port in ports: if port.external_port in self._used_ports: raise AddressInUse( address=(b"0.0.0.0", port.external_port), apierror=APIError('fake api response from server', response=make_response( 500, 'fake response')), ) all_ports = set(range(2**15, 2**16)) assigned_ports = [] for port in ports: if port.external_port == 0: available_ports = pset(all_ports) - self._used_ports assigned = next(iter(available_ports)) port = port.set(external_port=assigned) assigned_ports.append(port) self._used_ports = self._used_ports.add(port.external_port) self._units[unit_name] = Unit(name=unit_name, container_name=unit_name, container_image=image_name, ports=frozenset(assigned_ports), environment=environment, volumes=frozenset(volumes), activation_state=u'active', mem_limit=mem_limit, cpu_shares=cpu_shares, restart_policy=restart_policy, command_line=command_line, swappiness=swappiness) return succeed(None)
def test_scale_with_api_returns_errors(self, mock_stdout): """ Test that when scaling if the API returns an error, that error is handled and the remaining threads continue. """ service = self.create_service('web') next_number = service._next_container_number() service.create_container(number=next_number, quiet=True) with mock.patch( 'compose.container.Container.create', side_effect=APIError(message="testing", response={}, explanation="Boom")): service.scale(3) self.assertEqual(len(service.containers()), 1) self.assertTrue(service.containers()[0].is_running) self.assertIn("ERROR: for 2 Boom", mock_stdout.getvalue())
def get_image(self, image): if not image: raise APIError(HTTPError('500 Server Error'), None, explanation='Usage: image_export IMAGE [IMAGE...]') layers = [] next_layer_id = image while next_layer_id: layer = normalizeimage(self._findlayer(next_layer_id), copy=True) layers.append(layer) next_layer_id = layers[-1][':parent_id'] image_file = BytesIO() mtime = time() with tarfile_open(mode='w', fileobj=image_file) as image_tar_file: for layer in layers: ti_dir = TarInfo(layer[':id']) ti_dir.mtime = mtime ti_dir.mode = 0o755 ti_dir.type = DIRTYPE image_tar_file.addfile(ti_dir) layer_tar_src_path = ospath_join(self._my_dir, 'data', layer[':short_id'], 'layer.tar') with open(layer_tar_src_path, 'rb') as layer_tar_src_file: layer_tar_dst_path = '{}/layer.tar'.format(layer[':id']) ti_layer = image_tar_file.gettarinfo( layer_tar_src_path, layer_tar_dst_path) ti_layer.mtime = mtime ti_layer.mode = 0o644 ti_layer.uid = ti_layer.gid = 0 ti_layer.uname = ti_layer.gname = '' image_tar_file.addfile(ti_layer, fileobj=layer_tar_src_file) image_file.seek(0) return image_file
def test_is_server_error_500(self): """Report server error on 500 response.""" resp = requests.Response() resp.status_code = 500 err = APIError('', response=resp) assert err.is_server_error() is True
def test_is_client_error_400(self): """Report client error on 400 response.""" resp = requests.Response() resp.status_code = 400 err = APIError('', response=resp) assert err.is_client_error() is True