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
