def mock_import_repository_task(*args, **kwargs):
resp = requests.Response()
resp.status_code = 200
resp._content_consumed = True
return resp
def mock_wait():
resp = requests.Response()
resp.status_code = status_code
raise APIError('Bad server', resp)
def MakeResponse(code=500, data=""):
"""A helper for creating a HTTPError exception."""
response = requests.Response()
response.status_code = code
response._content = data
return response
def create_response(content: bytes, status_code: int) -> requests.Response:
res = requests.Response()
cast(Any, res)._content = content
res.status_code = status_code
return res
def test_misc(self):
"""
Tests miscellaneous functions
"""
service_url = 'http://somehost.com/service'
with patch('cadcutils.net.ws.WsCapabilities') as caps_mock:
caps_mock.return_value.get_service_host.return_value =\
'somehost.com'
caps_mock.return_value.get_access_url.return_value = service_url
client = ws.BaseWsClient("someresourceID", auth.Subject(),
'TestApp')
self.assertEqual('{}'.format(service_url),
client._get_url(('myfeature', None)))
caps_mock.return_value.get_access_url.assert_called_with(
'myfeature')
self.assertEqual('{}'.format(service_url),
client._get_url(('myfeature', '')))
test_host = 'testhost.com'
with patch('cadcutils.net.ws.os.makedirs'):
client = ws.BaseWsClient("someresourceID",
auth.Subject(),
'TestApp',
host=test_host)
self.assertEqual(test_host, client.host)
# test with resource as url
with patch('cadcutils.net.ws.WsCapabilities') as caps_mock:
caps_mock.return_value.get_service_host.return_value =\
'somehost.com'
cm = Mock()
cm.get_access_url.return_value = "http://host/availability"
caps_mock.return_value = cm
client = ws.BaseWsClient("someresourceID", auth.Subject(),
'TestApp')
resource_url = 'http://someurl.com/path/'
self.assertEqual(resource_url, client._get_url(resource_url))
# repeat with overriden host name
client = ws.BaseWsClient("someresourceID",
auth.Subject(),
'TestApp',
host=test_host)
# same result
self.assertEqual(resource_url, client._get_url(resource_url))
# test exceptions with different status in the response
session = ws.RetrySession()
response = requests.Response()
response.status_code = requests.codes.not_found
with self.assertRaises(exceptions.NotFoundException):
session.check_status(response)
response.status_code = requests.codes.unauthorized
with self.assertRaises(exceptions.UnauthorizedException):
session.check_status(response)
response.status_code = requests.codes.forbidden
with self.assertRaises(exceptions.ForbiddenException):
session.check_status(response)
response.status_code = requests.codes.bad_request
with self.assertRaises(exceptions.BadRequestException):
session.check_status(response)
response.status_code = requests.codes.conflict
with self.assertRaises(exceptions.AlreadyExistsException):
session.check_status(response)
response.status_code = requests.codes.internal_server_error
with self.assertRaises(exceptions.InternalServerException):
session.check_status(response)
response.status_code = requests.codes.unavailable
with self.assertRaises(requests.HTTPError):
session.check_status(response)
response.status_code = requests.codes.not_extended
with self.assertRaises(exceptions.UnexpectedException):
session.check_status(response)
def connection_send(self, *args, **kwargs):
reject = requests.Response()
reject.url = "http://www.example.org/"
reject.status_code = 401
reject.connection = connection
return reject
def test_negotate_value_extraction_none(self):
response = requests.Response()
response.headers = {}
self.assertTrue(
requests_kerberos.kerberos_._negotiate_value(response) is None)
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
def test_raw_deserializer():
raw_deserializer = ContentDecodePolicy()
def build_response(body, content_type=None):
class MockResponse(HttpResponse):
def __init__(self, body, content_type):
super(MockResponse, self).__init__(None, None)
self._body = body
self.content_type = content_type
def body(self):
return self._body
return PipelineResponse(None, MockResponse(body, content_type),
PipelineContext(None, stream=False))
response = build_response(b"<groot/>", content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result.tag == "groot"
# The basic deserializer works with unicode XML
response = build_response(u'<groot language="français"/>'.encode('utf-8'),
content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result.attrib["language"] == u"français"
# Catch some weird situation where content_type is XML, but content is JSON
response = build_response(b'{"ugly": true}',
content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["ugly"] is True
# Be sure I catch the correct exception if it's neither XML nor JSON
with pytest.raises(DecodeError):
response = build_response(b'gibberish', content_type="application/xml")
raw_deserializer.on_response(
None,
response,
)
with pytest.raises(DecodeError):
response = build_response(b'{{gibberish}}',
content_type="application/xml")
raw_deserializer.on_response(None, response)
# Simple JSON
response = build_response(b'{"success": true}',
content_type="application/json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with complex content_type
response = build_response(
b'{"success": true}',
content_type="application/vnd.microsoft.appconfig.kv.v1+json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with complex content_type, v2
response = build_response(
b'{"success": true}',
content_type="text/vnd.microsoft.appconfig.kv.v1+json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# For compat, if no content-type, decode JSON
response = build_response(b'"data"')
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result == "data"
# Try with a mock of requests
req_response = requests.Response()
req_response.headers["content-type"] = "application/json"
req_response._content = b'{"success": true}'
req_response._content_consumed = True
response = PipelineResponse(None,
RequestsTransportResponse(None, req_response),
PipelineContext(None, stream=False))
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
def test_status_code_500(self):
"""The status_code property is present with 500 response."""
resp = requests.Response()
resp.status_code = 500
err = APIError('', response=resp)
assert err.status_code == 500
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 mock_send(*args, **kwargs):
self.assertEqual(kwargs.get('timeout'), request_timeout)
response = requests.Response()
response.status_code = 200
response._content = b'{}'
return response
def FakeUrlOpen(url=None, data=None, **_):
self.urls.append(url)
response = requests.Response()
response.status_code = 200
response._content = data
return response
def test_is_error_300(self):
"""Report no error on 300 response."""
resp = requests.Response()
resp.status_code = 300
err = APIError('', response=resp)
assert err.is_error() is False
def __init__(self):
self.session = requests.Session()
self.response = requests.Response()
self.result = RecordParser()
def raise_status_code(status_code):
response = requests.Response()
response.status_code = status_code
raise requests.HTTPError(response=response)
def __init__(self):
self.response = requests.Response()
self.response.status_code = 200
self.response._content = 'apache/airflow'.encode('ascii', 'ignore')
def test_tag_and_push_plugin(tmpdir, monkeypatch, image_name, logs,
should_raise, has_config, use_secret,
reactor_config_map, file_name,
dockerconfig_contents):
if MOCK:
mock_docker()
flexmock(docker.APIClient,
push=lambda iid, **kwargs: iter(logs),
login=lambda username, registry, dockercfg_path:
{'Status': 'Login Succeeded'})
tasker = DockerTasker(retry_times=0)
workflow = DockerBuildWorkflow({
"provider": "git",
"uri": "asd"
}, TEST_IMAGE)
workflow.tag_conf.add_primary_image(image_name)
setattr(workflow, 'builder', X)
secret_path = None
if use_secret:
temp_dir = mkdtemp()
with open(os.path.join(temp_dir, file_name), "w+") as dockerconfig:
dockerconfig.write(json.dumps(dockerconfig_contents))
dockerconfig.flush()
secret_path = temp_dir
CONFIG_DIGEST = 'sha256:2c782e3a93d34d89ea4cf54052768be117caed54803263dd1f3798ce42aac14e'
media_type = 'application/vnd.docker.distribution.manifest.v2+json'
manifest_json = {
'config': {
'digest': CONFIG_DIGEST,
'mediaType': 'application/octet-stream',
'size': 4132
},
'layers': [{
'digest':
'sha256:16dc1f96e3a1bb628be2e00518fec2bb97bd5933859de592a00e2eb7774b6ecf',
'mediaType': 'application/vnd.docker.image.rootfs.diff.tar.gzip',
'size': 71907148
}, {
'digest':
'sha256:cebc0565e1f096016765f55fde87a6f60fdb1208c0b5017e35a856ff578f5ccb',
'mediaType': 'application/vnd.docker.image.rootfs.diff.tar.gzip',
'size': 3945724
}],
'mediaType':
media_type,
'schemaVersion':
2
}
config_json = {
'config': {
'Size':
12509448,
'architecture':
'amd64',
'author':
'Red Hat, Inc.',
'config': {
'Cmd': ['/bin/rsyslog.sh'],
'Entrypoint': None,
'Image':
'c3fb36aafd5692d2a45115d32bb120edb6edf6c0c3c783ed6592a8dab969fb88',
'Labels': {
'Architecture': 'x86_64',
'Authoritative_Registry': 'registry.access.redhat.com',
'BZComponent': 'rsyslog-docker',
'Name': 'rhel7/rsyslog',
'Release': '28.vrutkovs.31',
'Vendor': 'Red Hat, Inc.',
'Version': '7.2',
},
},
'created':
'2016-10-07T10:20:05.38595Z',
'docker_version':
'1.9.1',
'id':
'1ca220fbc2aed7c141b236c8729fe59db5771b32bf2da74e4a663407f32ec2a2',
'os':
'linux',
'parent':
'47eed7a8ea3f131e9281ae09fcbfb0041872fd8b74a048f1c739302c8148505d'
},
'container_config': {
'foo': 'bar',
'spam': 'maps'
},
'id':
'1ca220fbc2aed7c141b236c8729fe59db5771b32bf2da74e4a663407f32ec2a2',
'parent_id':
'c3fb36aafd5692d2a45115d32bb120edb6edf6c0c3c783ed6592a8dab969fb88'
}
# To test out the lack of a config, we really should be testing what happens
# when we only return a v1 response and not a v2 response at all; what are
# doing now is simply testing that if we return a None instead of json for the
# config blob, that None is stored rather than json
if not has_config:
config_json = None
manifest_latest_url = "https://{}/v2/{}/manifests/latest".format(
LOCALHOST_REGISTRY, TEST_IMAGE)
manifest_url = "https://{}/v2/{}/manifests/{}".format(
LOCALHOST_REGISTRY, TEST_IMAGE, DIGEST_V2)
config_blob_url = "https://{}/v2/{}/blobs/{}".format(
LOCALHOST_REGISTRY, TEST_IMAGE, CONFIG_DIGEST)
# We return our v2 manifest in the mocked v1 response as a placeholder - only the
# digest matters anyways
manifest_response_v1 = requests.Response()
(flexmock(manifest_response_v1,
status_code=200,
json=manifest_json,
headers={
'Content-Type':
'application/vnd.docker.distribution.manifest.v1+json',
'Docker-Content-Digest': DIGEST_V1
}))
manifest_response_v2 = requests.Response()
(flexmock(manifest_response_v2,
status_code=200,
json=manifest_json,
headers={
'Content-Type':
'application/vnd.docker.distribution.manifest.v2+json',
'Docker-Content-Digest': DIGEST_V2
}))
manifest_response_v2_list = requests.Response()
(flexmock(manifest_response_v2_list,
raise_for_status=lambda: None,
json=manifest_json,
headers={
'Content-Type':
'application/vnd.docker.distribution.manifest.list.v2+json',
}))
config_blob_response = requests.Response()
(flexmock(config_blob_response, status_code=200, json=config_json))
def custom_get(method, url, headers, **kwargs):
if url == manifest_latest_url:
# For a manifest stored as v2 or v1, the docker registry defaults to
# returning a v1 manifest if a v2 manifest is not explicitly requested
if headers[
'Accept'] == 'application/vnd.docker.distribution.manifest.v2+json':
return manifest_response_v2
else:
return manifest_response_v1
if headers[
'Accept'] == 'application/vnd.docker.distribution.manifest.list.v2+json':
return manifest_response_v2_list
if url == manifest_url:
return manifest_response_v2
if url == config_blob_url:
return config_blob_response
mock_get_retry_session()
(flexmock(
requests.Session).should_receive('request').replace_with(custom_get))
if reactor_config_map:
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'registries': [{
'url': LOCALHOST_REGISTRY,
'insecure': True,
'auth': {'cfg_path': secret_path},
}]})
runner = PostBuildPluginsRunner(tasker, workflow,
[{
'name': TagAndPushPlugin.key,
'args': {
'registries': {
LOCALHOST_REGISTRY: {
'insecure': True,
'secret': secret_path
}
}
},
}])
if should_raise:
with pytest.raises(PluginFailedException):
runner.run()
else:
output = runner.run()
image = output[TagAndPushPlugin.key][0]
tasker.remove_image(image)
assert len(workflow.push_conf.docker_registries) > 0
if MOCK:
# we only test this when mocking docker because we don't expect
# running actual docker against v2 registry
expected_digest = ManifestDigest(v1=DIGEST_V1,
v2=DIGEST_V2,
oci=None)
assert workflow.push_conf.docker_registries[0].digests[image_name].v1 == \
expected_digest.v1
assert workflow.push_conf.docker_registries[0].digests[image_name].v2 == \
expected_digest.v2
assert workflow.push_conf.docker_registries[0].digests[image_name].oci == \
expected_digest.oci
if has_config:
assert isinstance(
workflow.push_conf.docker_registries[0].config, dict)
else:
assert workflow.push_conf.docker_registries[0].config is None
def test_negotate_value_extraction(self):
response = requests.Response()
response.headers = {'www-authenticate': 'negotiate token'}
self.assertEqual(
requests_kerberos.kerberos_._negotiate_value(response), 'token')
def test_tag_and_push_plugin_oci(tmpdir, monkeypatch, use_secret, fail_push,
caplog, reactor_config_map):
# For now, we don't want to require having a skopeo and an OCI-supporting
# registry in the test environment
if MOCK:
mock_docker()
else:
return
tasker = DockerTasker()
workflow = DockerBuildWorkflow({
"provider": "git",
"uri": "asd"
}, TEST_IMAGE)
setattr(workflow, 'builder', X)
secret_path = None
if use_secret:
temp_dir = mkdtemp()
with open(os.path.join(temp_dir, ".dockercfg"), "w+") as dockerconfig:
dockerconfig_contents = {
LOCALHOST_REGISTRY: {
"username": "******",
"email": "*****@*****.**",
"password": "******"
}
}
dockerconfig.write(json.dumps(dockerconfig_contents))
dockerconfig.flush()
secret_path = temp_dir
CONFIG_DIGEST = 'sha256:b79482f7dcab2a326c1e8c7025a4336d900e99f50db8b35a659fda67b5ebb3c2'
MEDIA_TYPE = 'application/vnd.oci.image.manifest.v1+json'
REF_NAME = "app/org.gnome.eog/x86_64/master"
manifest_json = {
"schemaVersion":
2,
"mediaType":
"application/vnd.oci.image.manifest.v1+json",
"config": {
"mediaType": MEDIA_TYPE,
"digest": CONFIG_DIGEST,
"size": 314
},
"layers": [{
"mediaType": "application/vnd.oci.image.layer.v1.tar+gzip",
"digest":
"sha256:fd2b341d2ff3751ecdee8d8daacaa650d8a1703360c85d4cfc452d6ec32e147f",
"size": 1863477
}],
"annotations": {
"org.flatpak.commit-metadata.xa.ref":
"YXBwL29yZy5nbm9tZS5lb2cveDg2XzY0L21hc3RlcgAAcw==", # noqa
"org.flatpak.body":
"Name: org.gnome.eog\nArch: x86_64\nBranch: master\nBuilt with: Flatpak 0.9.7\n", # noqa
"org.flatpak.commit-metadata.xa.metadata":
"W0FwcGxpY2F0aW9uXQpuYW1lPW9yZy5nbm9tZS5lb2cKcnVudGltZT1vcmcuZmVkb3JhcHJvamVjdC5QbGF0Zm9ybS94ODZfNjQvMjYKc2RrPW9yZy5mZWRvcmFwcm9qZWN0LlBsYXRmb3JtL3g4Nl82NC8yNgpjb21tYW5kPWVvZwoKW0NvbnRleHRdCnNoYXJlZD1pcGM7CnNvY2tldHM9eDExO3dheWxhbmQ7c2Vzc2lvbi1idXM7CmZpbGVzeXN0ZW1zPXhkZy1ydW4vZGNvbmY7aG9zdDt+Ly5jb25maWcvZGNvbmY6cm87CgpbU2Vzc2lvbiBCdXMgUG9saWN5XQpjYS5kZXNydC5kY29uZj10YWxrCgpbRW52aXJvbm1lbnRdCkRDT05GX1VTRVJfQ09ORklHX0RJUj0uY29uZmlnL2Rjb25mCgAAcw==", # noqa
"org.flatpak.download-size": "1863477",
"org.flatpak.commit-metadata.xa.download-size": "AAAAAAAdF/IAdA==",
"org.flatpak.commit-metadata.xa.installed-size":
"AAAAAABDdgAAdA==",
"org.flatpak.subject": "Export org.gnome.eog",
"org.flatpak.installed-size": "4421120",
"org.flatpak.commit":
"d7b8789350660724b20643ebb615df466566b6d04682fa32800d3f10116eec54", # noqa
"org.flatpak.metadata":
"[Application]\nname=org.gnome.eog\nruntime=org.fedoraproject.Platform/x86_64/26\nsdk=org.fedoraproject.Platform/x86_64/26\ncommand=eog\n\n[Context]\nshared=ipc;\nsockets=x11;wayland;session-bus;\nfilesystems=xdg-run/dconf;host;~/.config/dconf:ro;\n\n[Session Bus Policy]\nca.desrt.dconf=talk\n\n[Environment]\nDCONF_USER_CONFIG_DIR=.config/dconf\n", # noqa
"org.opencontainers.image.ref.name": REF_NAME,
"org.flatpak.timestamp": "1499376525"
}
}
config_json = {
"created": "2017-07-06T21:28:45Z",
"architecture": "arm64",
"os": "linux",
"config": {
"Memory": 0,
"MemorySwap": 0,
"CpuShares": 0
},
"rootfs": {
"type":
"layers",
"diff_ids": [
"sha256:4c5160fea65110aa1eb8ca022e2693bb868367c2502855887f21c77247199339"
]
}
}
# Add a mock OCI image to exported_image_sequence; this forces the tag_and_push
# plugin to push with skopeo rather than with 'docker push'
# Since we are always mocking the push for now, we can get away with a stub image
oci_dir = os.path.join(str(tmpdir), 'oci-image')
os.mkdir(oci_dir)
with open(os.path.join(oci_dir, "index.json"), "w") as f:
f.write('"Not a real index.json"')
with open(os.path.join(oci_dir, "oci-layout"), "w") as f:
f.write('{"imageLayoutVersion": "1.0.0"}')
os.mkdir(os.path.join(oci_dir, 'blobs'))
metadata = get_exported_image_metadata(oci_dir, IMAGE_TYPE_OCI)
metadata['ref_name'] = REF_NAME
workflow.exported_image_sequence.append(metadata)
oci_tarpath = os.path.join(str(tmpdir), 'oci-image.tar')
with open(oci_tarpath, "wb") as f:
with tarfile.TarFile(mode="w", fileobj=f) as tf:
for f in os.listdir(oci_dir):
tf.add(os.path.join(oci_dir, f), f)
metadata = get_exported_image_metadata(oci_tarpath, IMAGE_TYPE_OCI_TAR)
metadata['ref_name'] = REF_NAME
workflow.exported_image_sequence.append(metadata)
# Mock the subprocess call to skopeo
def check_check_output(args, **kwargs):
if fail_push:
raise subprocess.CalledProcessError(returncode=1,
cmd=args,
output="Failed")
assert args[0] == 'skopeo'
if use_secret:
assert '--dest-creds=user:mypassword' in args
assert '--dest-tls-verify=false' in args
assert args[-2] == 'oci:' + oci_dir + ':' + REF_NAME
assert args[
-1] == 'docker://' + LOCALHOST_REGISTRY + '/' + TEST_IMAGE_NAME
return ''
(flexmock(subprocess).should_receive("check_output").once().replace_with(
check_check_output))
# Mock out the response from the registry once the OCI image is uploaded
manifest_latest_url = "https://{}/v2/{}/manifests/latest".format(
LOCALHOST_REGISTRY, TEST_IMAGE)
manifest_url = "https://{}/v2/{}/manifests/{}".format(
LOCALHOST_REGISTRY, TEST_IMAGE, DIGEST_OCI)
config_blob_url = "https://{}/v2/{}/blobs/{}".format(
LOCALHOST_REGISTRY, TEST_IMAGE, CONFIG_DIGEST)
manifest_response = requests.Response()
(flexmock(manifest_response,
raise_for_status=lambda: None,
json=manifest_json,
headers={
'Content-Type': MEDIA_TYPE,
'Docker-Content-Digest': DIGEST_OCI
}))
manifest_unacceptable_response = requests.Response()
(flexmock(manifest_unacceptable_response,
status_code=404,
json={"errors": [{
"code": "MANIFEST_UNKNOWN"
}]}))
config_blob_response = requests.Response()
(flexmock(config_blob_response,
raise_for_status=lambda: None,
json=config_json))
def custom_get(method, url, headers, **kwargs):
if url == manifest_latest_url:
if headers['Accept'] == MEDIA_TYPE:
return manifest_response
else:
return manifest_unacceptable_response
if url == manifest_url:
return manifest_response
if url == config_blob_url:
return config_blob_response
mock_get_retry_session()
(flexmock(
requests.Session).should_receive('request').replace_with(custom_get))
if reactor_config_map:
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'registries': [{
'url': LOCALHOST_REGISTRY,
'insecure': True,
'auth': {'cfg_path': secret_path},
}]})
runner = PostBuildPluginsRunner(tasker, workflow,
[{
'name': TagAndPushPlugin.key,
'args': {
'registries': {
LOCALHOST_REGISTRY: {
'insecure': True,
'secret': secret_path
}
}
},
}])
with caplog.at_level(logging.DEBUG):
if fail_push:
with pytest.raises(PluginFailedException):
output = runner.run()
else:
output = runner.run()
for r in caplog.records:
assert 'mypassword' not in r.getMessage()
if not fail_push:
image = output[TagAndPushPlugin.key][0]
tasker.remove_image(image)
assert len(workflow.push_conf.docker_registries) > 0
assert workflow.push_conf.docker_registries[0].digests[
TEST_IMAGE_NAME].v1 is None
assert workflow.push_conf.docker_registries[0].digests[
TEST_IMAGE_NAME].v2 is None
assert workflow.push_conf.docker_registries[0].digests[
TEST_IMAGE_NAME].oci == DIGEST_OCI
assert workflow.push_conf.docker_registries[0].config is config_json
def make_response(content, status_code=200):
response = requests.Response()
response.status_code = status_code
response._content = content
response.encoding = 'utf-8'
return response
def _getTarget(self):
from gsocial.utils.inspection.gree import InspectionGree
res = requests.Response()
return InspectionGree(res)
def test_retry(self, send_mock, time_mock):
request = Mock()
send_mock.return_value = Mock()
rs = ws.RetrySession(False)
rs.send(request)
send_mock.assert_called_with(request, timeout=30)
# retry to user defined timeout
send_mock.return_value = Mock()
rs = ws.RetrySession(False)
rs.send(request, timeout=77)
send_mock.assert_called_with(request, timeout=77)
# mock delays for the 'Connection reset by peer error'
# one connection error delay = DEFAULT_RETRY_DELAY
send_mock.reset_mock()
rs = ws.RetrySession()
# connection error that triggers retries
ce = requests.exceptions.ConnectionError()
ce.errno = 104
response = requests.Response()
response.status_code = requests.codes.ok
send_mock.side_effect = [ce, response]
rs.send(request)
time_mock.assert_called_with(DEFAULT_RETRY_DELAY)
# two connection error delay = DEFAULT_RETRY_DELAY
send_mock.reset_mock()
time_mock.reset_mock()
rs = ws.RetrySession()
# connection error that triggers retries
ce = requests.exceptions.ConnectionError()
ce.errno = 104
response = requests.Response()
response.status_code = requests.codes.ok
send_mock.side_effect = [ce, ce, response] # two connection errors
rs.send(request)
calls = [call(DEFAULT_RETRY_DELAY), call(DEFAULT_RETRY_DELAY * 2)]
time_mock.assert_has_calls(calls)
# set the start retry to a large number and see how it is capped
# to MAX_RETRY_DELAY
send_mock.reset_mock()
time_mock.reset_mock()
rs = ws.RetrySession(start_delay=MAX_RETRY_DELAY / 2 + 1)
# connection error that triggers retries
ce = requests.exceptions.ConnectionError()
ce.errno = 104
response = requests.Response()
response.status_code = requests.codes.ok
send_mock.side_effect = [ce, ce, response] # two connection errors
rs.send(request)
calls = (call(MAX_RETRY_DELAY / 2 + 1), call(MAX_RETRY_DELAY))
time_mock.assert_has_calls(calls)
# return the error all the time
send_mock.reset_mock()
time_mock.reset_mock()
rs = ws.RetrySession(start_delay=MAX_RETRY_DELAY / 2 + 1)
# connection error that triggers retries
ce = requests.exceptions.ConnectionError()
ce.errno = 104
# make sure the mock returns more errors than the maximum number
# of retries allowed
http_errors = []
i = 0
while i <= MAX_NUM_RETRIES:
http_errors.append(ce)
i += 1
send_mock.side_effect = http_errors
with self.assertRaises(exceptions.HttpException):
rs.send(request)
# return the connection error other than 104 - connection reset by peer
send_mock.reset_mock()
time_mock.reset_mock()
rs = ws.RetrySession(start_delay=MAX_RETRY_DELAY / 2 + 1)
# connection error that triggers retries
ce = requests.exceptions.ConnectionError()
ce.errno = 105
send_mock.side_effect = ce
with self.assertRaises(exceptions.HttpException):
rs.send(request)
# return HttpError 503 with Retry-After
send_mock.reset_mock()
time_mock.reset_mock()
rs = ws.RetrySession()
server_delay = 5
# connection error that triggers retries
he = requests.exceptions.HTTPError()
he.response = requests.Response()
he.response.status_code = requests.codes.unavailable
he.response.headers[SERVICE_RETRY] = server_delay
response = requests.Response()
response.status_code = requests.codes.ok
send_mock.side_effect = [he, response]
rs.send(request)
calls = [call(server_delay)]
time_mock.assert_has_calls(calls)
# return HttpError 503 with Retry-After with an invalid value
send_mock.reset_mock()
time_mock.reset_mock()
start_delay = 66
rs = ws.RetrySession(start_delay=start_delay)
server_delay = 'notnumber'
# connection error that triggers retries
he = requests.exceptions.HTTPError()
he.response = requests.Response()
he.response.status_code = requests.codes.unavailable
he.response.headers[SERVICE_RETRY] = server_delay
response = requests.Response()
response.status_code = requests.codes.ok
send_mock.side_effect = [he, response]
rs.send(request)
calls = [call(start_delay)] # uses the default delay
time_mock.assert_has_calls(calls)
# return HttpError 503 with no Retry-After
send_mock.reset_mock()
time_mock.reset_mock()
start_delay = 66
rs = ws.RetrySession(start_delay=start_delay)
he = requests.exceptions.HTTPError()
he.response = requests.Response()
he.response.status_code = requests.codes.unavailable
response = requests.Response()
response.status_code = requests.codes.ok
send_mock.side_effect = [he, response]
rs.send(request)
calls = [call(start_delay)] # uses the default delay
time_mock.assert_has_calls(calls)
# tests non-transient errors
send_mock.reset_mock()
time_mock.reset_mock()
rs = ws.RetrySession()
he = requests.exceptions.HTTPError()
he.response = requests.Response()
he.response.status_code = requests.codes.internal_server_error
send_mock.side_effect = he
with self.assertRaises(exceptions.HttpException):
rs.send(request)
def get(self, *args, **kwargs):
response = requests.Response()
response.status_code = 401
return response
def _build_response_object(status_code=200, content=""):
resp = requests.Response()
resp.status_code = status_code
resp._content = content.encode("utf8")
return resp
def _make_http_response(code=200): """A helper for creating HTTP responses.""" response = requests.Response() response.status_code = code return response
def MakeHTTPException(code=500, msg="Error"):
"""A helper for creating a HTTPError exception."""
response = requests.Response()
response.status_code = code
return requests.ConnectionError(msg, response=response)
return H2OOrdinalModelMetrics.make(keyvals)
if schema == "ModelMetricsAutoEncoderV3":
return H2OAutoEncoderModelMetrics.make(keyvals)
return super(H2OResponse, cls).__new__(cls, keyvals)
# def __getattr__(self, key):
# """This gets invoked for any attribute "key" that is NOT yet defined on the object."""
# if key in self:
# return self[key]
# return None
# Find the exception that occurs on invalid JSON input
JSONDecodeError, _r = None, None
try:
_r = requests.Response()
_r._content = b"haha"
_r.json()
except Exception as exc:
JSONDecodeError = type(exc)
del _r
#-----------------------------------------------------------------------------------------------------------------------
# Deprecated method implementations
#-----------------------------------------------------------------------------------------------------------------------
__H2OCONN__ = H2OConnection(
) # Latest instantiated H2OConnection object. Do not use in any new code!
__H2O_REST_API_VERSION__ = 3 # Has no actual meaning
def post_cb(resp):
r = requests.Response()
r.status_code = resp.code
r.headers.update(resp.headers.getAllRawHeaders())
return treq.content(resp).addCallback(post_data_cb, r)
def test_amazon(self):
r = requests.Response()
r.status_code = 400
r.raw = RequestsBytesIO()
e = github3.models.GitHubError(r)
assert e.message == '[No message]'