def _invalid_billing(self):
valid_response = MagicMock()
valid_response.status_code = 200
valid_response.json.side_effect = [OFFERING]
invalid_response = MagicMock()
invalid_response.status_code = 400
ordering_management.requests.get.side_effect = [valid_response, invalid_response]
def test_handle_response(self):
connection = Connection("store.mybigcommerce.com", ("user", "abcdef"))
# A normal, 200-ok response
data = {"name": "Shirt"}
res = MagicMock()
res.headers = {"Content-Type": "application/json"}
res.status_code = 200
res.content = json.dumps(data)
res.json.return_value = data
self.assertEqual(connection._handle_response("products/1", res), data)
res.status_code = 500
self.assertRaisesHttpException(
ServerException,
lambda: connection._handle_response("products/1", res),
# Test all of the properties of a HttpException
500,
{"Content-Type": "application/json"},
json.dumps(data),
)
res.status_code = 404
self.assertRaisesHttpException(
ClientRequestException, lambda: connection._handle_response("products/1", res), 404
)
res.status_code = 301
self.assertRaisesHttpException(
RedirectionException, lambda: connection._handle_response("products/1", res), 301
)
def create_mock_response(url, response_type, **kwargs):
response = MagicMock()
response.request.url = url
response.request.method = kwargs.get("method", "GET")
response.request.headers = {}
response.request.body = None
if response_type == "redirect":
response.status_code = 301
response.headers = {"location": kwargs["location"]}
elif response_type == "error":
response.status_code = kwargs.get("status_code", 500)
response.reason = kwargs.get("reason", "fake reason")
response.text = '{{"reason":"{}"}}'.format(kwargs.get("reason", "fake reason"))
response.json = lambda: json.loads(response.text)
elif response_type == "stream":
response.status_code = kwargs.get("status_code", 200)
response.headers = {
"content-disposition": 'attachment; filename="fname.ext"',
"content-type": "application/octet-stream",
"content-length": len(response.text),
}
response.iter_content = lambda buffer_size: IterateContents(
kwargs["contents"], kwargs["buffer_size"], kwargs.get("partial_start", 0), kwargs.get("partial_end", None)
)
else:
response.status_code = 200
response.text = kwargs["text"]
response.json = lambda: json.loads(response.text)
response.headers = {"content-type": "application/json", "content-length": len(response.text)}
return response
def test_handle_response(self):
connection = Connection('store.mybigcommerce.com', ('user', 'abcdef'))
# A normal, 200-ok response
data = {
'name': 'Shirt'
}
res = MagicMock()
res.headers = {'Content-Type': 'application/json'}
res.status_code = 200
res.content = json.dumps(data)
res.json.return_value = data
self.assertEqual(connection._handle_response('products/1', res), data)
res.status_code = 500
self.assertRaisesHttpException(ServerException,
lambda: connection._handle_response('products/1', res),
# Test all of the properties of a HttpException
500,
{'Content-Type': 'application/json'},
json.dumps(data))
res.status_code = 404
self.assertRaisesHttpException(ClientRequestException,
lambda: connection._handle_response('products/1', res), 404)
res.status_code = 301
self.assertRaisesHttpException(RedirectionException,
lambda: connection._handle_response('products/1', res), 301)
def test_put_observation(self, mock_conn, caps_mock):
caps_mock.get_service_host.return_value = 'some.host.com'
caps_mock.return_value.get_access_url.return_value =\
'http://serviceurl/caom2repo/pub'
collection = 'cfht'
observation_id = '7000000o'
service = 'caom2repo'
service_url = 'www.cadc.nrc.ca'
obs = SimpleObservation(collection, observation_id)
subject = auth.Subject(certificate='somefile.pem')
level = logging.DEBUG
visitor = CAOM2RepoClient(subject, level, host=service_url)
response = MagicMock()
response.status = 200
mock_conn.return_value = response
iobuffer = BytesIO()
ObservationWriter().write(obs, iobuffer)
obsxml = iobuffer.getvalue()
response.content = obsxml
visitor.put_observation(obs)
self.assertEqual('PUT', mock_conn.call_args[0][0].method)
self.assertEqual(
'/{}/pub/{}/{}'.format(service, collection, observation_id),
mock_conn.call_args[0][0].path_url)
self.assertEqual('application/xml',
mock_conn.call_args[0][0].headers['Content-Type'])
self.assertEqual(obsxml, mock_conn.call_args[0][0].body)
# signal problems
http_error = requests.HTTPError()
response.status_code = 500
http_error.response = response
response.raise_for_status.side_effect = [http_error]
with self.assertRaises(exceptions.InternalServerException):
visitor.create(obs)
# temporary transient errors
http_error = requests.HTTPError()
response.status_code = 503
http_error.response = response
response.raise_for_status.side_effect = [http_error, None]
visitor.put_observation(obs)
# permanent transient errors
http_error = requests.HTTPError()
response.status_code = 503
http_error.response = response
def raise_error(): raise http_error
response.raise_for_status.side_effect = raise_error
with self.assertRaises(exceptions.HttpException):
visitor.put_observation(obs)
def test_data_for(self):
mock_data = {"test": "test"}
mock_response = MagicMock(spec=Response)
mock_response.data = mock_data
mock_response.status_code = 200
data = HtmlCommunityView.data_for(CommunityMock, mock_response)
self.assertEqual(data, mock_data)
mock_response.status_code = 300
data = HtmlCommunityView.data_for(CommunityMock, mock_response)
self.assertEqual(data, mock_data)
mock_response.status_code = 500 # or any other status
data = HtmlCommunityView.data_for(CommunityMock, mock_response)
self.assertIsNone(data)
data = HtmlCommunityView.data_for(CommunityMock, None)
self.assertIsNone(data)
def init_mock(self, json_data_file):
fake_response = MagicMock()
fake_response.status_code = 200
with open(json_data_file) as json_data:
response_data = json.load(json_data)
fake_response.json.return_value = response_data
return fake_response
def test_provider_redirects_on_success_preauth_payment(
self, mocked_redirect, mocked_post):
data = MagicMock()
data.return_value = {
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'payer': {'payer_info': 'test123'},
'transactions': [
{'related_resources': [{
'sale': {'links': ''},
'authorization': {'links': ''}}]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
request = MagicMock()
request.GET = {'token': 'test', 'PayerID': '1234'}
provider = PaypalProvider(
secret=SECRET, client_id=CLIENT_ID, capture=False)
provider.process_data(self.payment, request)
self.assertEqual(self.payment.status, 'preauth')
self.assertEqual(self.payment.captured_amount, Decimal('0'))
def test_add_new_entities(monkeypatch, json):
zmon_client = MagicMock()
resp = MagicMock()
resp.status_code = 200
zmon_client.add_entity.return_value = resp
existing_ids = ['1', '2', '3']
current_ids = ['2', '3', '4', '5']
existing_entities = [{'id': i, 'type': 'e-type'} for i in existing_ids]
all_current_entities = [{'id': i, 'type': 'e-type'} for i in existing_ids + current_ids]
new_entities, count = add_new_entities(all_current_entities, existing_entities, zmon_client, json=json)
expected = [{'id': '4', 'type': 'e-type'}, {'id': '5', 'type': 'e-type'}]
assert new_entities == expected
assert count == 0
calls = [call(e) for e in expected]
if not json:
zmon_client.add_entity.assert_has_calls(calls, any_order=True)
else:
zmon_client.add_entity.assert_not_called()
def test_process_results_bad_status(self):
test_object = MagicMock()
test_object.status_code = 'cookies'
self.assertRaises(ValueError, process_results, test_object)
expected_calls = []
self.assertListEqual(expected_calls, test_object.mock_calls)
def test_provider_raises_redirect_needed_on_success_captured_payment(self):
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id': transaction_id,
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'transactions': [
{'related_resources': [
{'sale': {'links': [
{'rel': 'refund', 'href': 'http://refund.com'}]}}
]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
self.provider.get_form(
payment=self.payment, data=PROCESS_DATA)
self.assertEqual(exc.args[0], self.payment.get_success_url())
links = self.provider._get_links(self.payment)
self.assertEqual(self.payment.status, 'confirmed')
self.assertEqual(self.payment.captured_amount, self.payment.total)
self.assertEqual(self.payment.transaction_id, transaction_id)
self.assertTrue('refund' in links)
def test_getContextForCollectionMappings_contextRecieved(self, mock_get):
mappingResponse = MagicMock(spec=Response)
collection = ["Some Results"]
mappingResponse.json.return_value = collection
mappingResponse.status_code = 200
mappingResponse.headers = []
mock_get.return_value = mappingResponse
collectionMappingsView = views.CollectionMappingsView()
collectionMappingsView.request = FakeRequest()
hash = {'collection': 'test', 'org': 'org1'}
collectionMappingsView.kwargs = hash
context = collectionMappingsView.get_context_data()
self.assertEquals(context['url_params'], {})
self.assertEquals(context['kwargs'], hash)
self.assertEquals(context['selected_tab'], 'Mappings')
self.assertEquals(context['results'], collection)
self.assertEquals(context['pagination_url'], '/foobar')
self.assertEquals(context['search_query'], '')
self.assertIsInstance(context['search_filters'], SearchFilterList)
# TODO: Revise sort assertion to work with new sort option definitions
# self.assertEquals(context['search_sort_options'], ['Best Match', 'Last Update (Desc)', 'Last Update (Asc)', 'Name (Asc)', 'Name (Desc)'])
self.assertEquals(context['search_sort'], '')
self.assertEquals(context['search_facets_json'], None)
def test_getters_from_invalid_queue_item():
# First we mock an HTTP 404 error response, which is what the Jenkins
# REST API will return when the endpoint referenced by our queue item
# no longer exists
mock_response = MagicMock()
mock_response.status_code = 404
# Mock a Jenkins REST API object with the relevant structures used by
# our queue item
mock_api = MagicMock()
mock_api.get_api_data.side_effect = HTTPError(response=mock_response)
expected_id = 1234
mock_api.url = "https://jenkins.server/queue/item/" + str(expected_id)
# Flex our code
q1 = QueueItem(mock_api)
# confirm the results
assert q1.uid == expected_id
assert q1.stuck is None
assert q1.blocked is None
assert q1.buildable is None
assert q1.reason is None
assert q1.waiting is None
assert q1.cancelled is None
assert q1.job is None
assert q1.build is None
def test_provider_raises_redirect_needed_on_success_preauth_payment(self):
provider = PaypalCardProvider(
secret=SECRET, client_id=CLIENT_ID, capture=False)
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id': transaction_id,
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'transactions': [
{'related_resources': [
{'authorization': {'links': [
{'rel': 'refund', 'href': 'http://refund.com'},
{'rel': 'capture', 'href': 'http://capture.com'}]}}
]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
provider.get_form(
payment=self.payment, data=PROCESS_DATA)
self.assertEqual(exc.args[0], self.payment.get_success_url())
links = provider._get_links(self.payment)
self.assertEqual(self.payment.status, 'preauth')
self.assertEqual(self.payment.captured_amount, Decimal('0'))
self.assertEqual(self.payment.transaction_id, transaction_id)
self.assertTrue('capture' in links)
self.assertTrue('refund' in links)
def test_add_image_with_file_object(self, mocked_os_path_getsize, mocked_os_path_isfile, mocked_requests_post, mocked_url, mocked_headers):
mocked_os_path_isfile.return_value = True
mocked_os_path_getsize.return_value = 7
response_mock = MagicMock()
response_mock.status_code = 201
mocked_requests_post.return_value = response_mock
mocked_url.return_value = 'url'
mocked_headers.return_value = {'Accept': 'application/json'}
content = 'content'
m = '__builtin__'
dummy_data = 'dummy_image_data_to_read'
if sys.version_info >= (3,):
m = 'builtins'
import io
sio = io.StringIO(dummy_data)
else:
import StringIO
sio = StringIO.StringIO(dummy_data)
# this should not be called
mocked_open = mock_open(read_data=content)
with patch(m + '.open', mocked_open):
result = self._client.add_image(sio)
mocked_requests_post.assert_called_once_with('url', data=dummy_data, headers={'Accept': 'application/json'})
def test_handle_http_error(self, transport, input):
status, error_cls = input
error_body_json = {
'message': 'error message',
'support_email': '*****@*****.**'
}
error_body_text = json.dumps(error_body_json)
mock_response = MagicMock()
mock_response.status_code = status
mock_response.text = error_body_text
mock_response.json.return_value = error_body_json
error = HTTPError('error message', status)
error.response = mock_response
with pytest.raises(error_cls) as excinfo:
transport._handle_http_error(error)
err = excinfo.value
assert err.message == 'error message'
assert err.status == status
assert err.raw == error_body_text
assert err.json == error_body_json
def test__request_basic_auth_fail(self):
response = MagicMock(spec=requests.Response())
response.status_code = 401
self.client.session.request = MagicMock(return_value=response)
self.assertEquals((False, "Unexpected HTTP status code [401]"),
self.client._request("http://example.com"))
def test_article_version_404(self, mock_requests_get):
response = MagicMock()
response.status_code = 404
mock_requests_get.return_value = response
status_code, versions = lax_provider.article_versions('08411', settings_mock)
self.assertEqual(status_code, 404)
self.assertIsNone(versions)
def test__request_retries_login(self, mock_login):
initial_xreply = {"return_code": 1, "content": "login_required"}
pre_login_response = MagicMock(spec=requests.Response())
pre_login_response.status_code = 200
pre_login_response.content = json.dumps(initial_xreply)
final_xreply = {"return_code": 0, "content": "success"}
post_login_response = MagicMock(spec=requests.Response())
post_login_response.status_code = 200
post_login_response.content = json.dumps(final_xreply)
side_effect = [pre_login_response, post_login_response]
self.client.session.request = MagicMock(side_effect=side_effect)
self.assertEquals((True, "success"),
self.client._request("http://example.com"))
def test_http_errors(monkeypatch):
resp = MagicMock()
resp.status_code = 404
resp.raise_for_status.side_effect = requests.HTTPError('Not Found')
get = MagicMock()
get.return_value = resp
monkeypatch.setattr('requests.get', get)
http = HttpWrapper('http://example.org')
# the code method will not raise an exception..
assert 404 == http.code()
for meth in ('time', 'json', 'cookies', 'headers'):
with pytest.raises(HttpError) as ex:
# ..but other methods will!
getattr(http, meth)()
assert 'Not Found' == ex.value.message
get.side_effect = requests.Timeout('timed out')
http = HttpWrapper('http://example.org')
with pytest.raises(HttpError) as ex:
http.time()
assert 'timeout' == ex.value.message
get.side_effect = requests.ConnectionError('connfail')
http = HttpWrapper('http://example.org')
with pytest.raises(HttpError) as ex:
http.code()
assert 'connection failed' == ex.value.message
get.side_effect = Exception('foofail')
http = HttpWrapper('http://example.org')
with pytest.raises(HttpError) as ex:
http.code()
assert 'foofail' == ex.value.message
def test_signups_worker_retries(self) -> None:
"""Tests the retry logic of signups queue."""
fake_client = self.FakeClient()
user_id = self.example_user('hamlet').id
data = {'user_id': user_id, 'id': 'test_missed'}
fake_client.queue.append(('signups', data))
def fake_publish(queue_name: str, event: Dict[str, Any], processor: Callable[[Any], None]) -> None:
fake_client.queue.append((queue_name, event))
fake_response = MagicMock()
fake_response.status_code = 400
fake_response.text = ujson.dumps({'title': ''})
with simulated_queue_client(lambda: fake_client):
worker = queue_processors.SignupWorker()
worker.setup()
with patch('zerver.worker.queue_processors.requests.post',
return_value=fake_response), \
patch('zerver.lib.queue.queue_json_publish',
side_effect=fake_publish), \
patch('logging.info'), \
self.settings(MAILCHIMP_API_KEY='one-two',
PRODUCTION=True,
ZULIP_FRIENDS_LIST_ID='id'):
worker.start()
self.assertEqual(data['failed_tries'], 4)
def _mock_response(self, status_code=404, headers={}, content='PAGE_NOT_FOUND'):
r = MagicMock(Response())
r.status_code = status_code
r.headers = CaseInsensitiveDict(headers if headers is not None else {})
r.content = content
r.ok = status_code < 400
return r
def test_http_errors(monkeypatch):
resp = MagicMock()
resp.status_code = 404
resp.raise_for_status.side_effect = requests.HTTPError("Not Found")
get = MagicMock()
get.return_value = resp
monkeypatch.setattr("requests.get", get)
http = HttpWrapper("http://example.org")
# the code method will not raise an exception..
assert 404 == http.code()
for meth in ("time", "json", "cookies", "headers"):
with pytest.raises(HttpError) as ex:
# ..but other methods will!
getattr(http, meth)()
assert "Not Found" == ex.value.message
get.side_effect = requests.Timeout("timed out")
http = HttpWrapper("http://example.org")
with pytest.raises(HttpError) as ex:
http.time()
assert "timeout" == ex.value.message
get.side_effect = requests.ConnectionError("connfail")
http = HttpWrapper("http://example.org")
with pytest.raises(HttpError) as ex:
http.code()
assert "connection failed" == ex.value.message
get.side_effect = Exception("foofail")
http = HttpWrapper("http://example.org")
with pytest.raises(HttpError) as ex:
http.code()
assert "foofail" == ex.value.message
def _build_mock_request(method):
status_values = {
'get': 200,
'put': 200,
'post': 201,
'delete': 204
}
# Build response
response = MagicMock()
response.status_code = status_values[method]
if method == 'get':
response.headers = {
'content-type': 'application/rdf+xml'
}
response.text = 'value returned'
def _mock_request(url, headers={}, data=''):
# Check headers
if 'Authorization' not in headers:
response.status_code = 401
if method == 'get' and 'Accept' not in headers:
response.status_code = 406
if (method == 'put' or method == 'post') and 'Content-Type' not in headers:
response.status_code = 415
response.url = url
return response
return _mock_request
def test_missing_keys(self):
http_session = MagicMock()
response = MagicMock()
http_session.get = MagicMock()
http_session.get.return_value = response
response.status_code = 200
response.content = "{}"
response.url = "http://example.com/?camli.mode=config"
conn = _connect(
'http://example.com/',
http_session=http_session,
)
self.assertEqual(
conn.blob_root,
None,
)
self.assertEqual(
conn.search_root,
None,
)
self.assertEqual(
conn.sign_root,
None,
)
def test_handle_error_503(self):
# Retry once more on 503 error
request = MagicMock()
request.status_code = 503
self.auth.handle_error(request)
self.assertEqual(self.auth.auth_token, 'auth_token')
request.connection.send.assert_called_with(request.request)
def test_get_calls(self):
resp = MagicMock()
resp.json = Mock()
resp.status_code = Mock()
with patch.object(Adapter, 'get', return_value=resp) as get_request:
self.accounts_adapter.get()
get_request.assert_any_call()
def test_delete(self):
response_mock = MagicMock(status_code=204)
self.engine.requests.request.return_value = response_mock
self.assertTrue(self.engine.delete('/test', {'value': 'test'}))
response_mock.status_code = MagicMock(return_value=401)
self.assertFalse(self.engine.delete('/test', {'value': 'test'}))
def test_handle_error_200(self):
# No op on no error
request = MagicMock()
request.status_code = 200
self.auth.handle_error(request)
self.assertEqual(self.auth.auth_token, 'auth_token')
self.assertFalse(request.request.send.called)
def test_article_version_200(self, mock_requests_get):
response = MagicMock()
response.status_code = 200
response.json.return_value = {'versions': [{'version': 1}]}
mock_requests_get.return_value = response
status_code, versions = lax_provider.article_versions('08411', settings_mock)
self.assertEqual(status_code, 200)
self.assertEqual(versions, [{'version': 1}])
def response(status_code):
mocked = MagicMock()
mocked.status_code = status_code
mocked.ok = 100 <= status_code < 400
return mocked
def make_response(self, text, status_code=200):
fake_response = MagicMock()
fake_response.text = text
fake_response.status_code = status_code
return fake_response
def test_enumerate(self):
http_session = MagicMock()
http_session.get = MagicMock()
response = MagicMock()
http_session.get.return_value = response
response.status_code = 200
response.content = """
{
"blobs": [
{
"blobRef": "dummy1",
"size": 5
},
{
"blobRef": "dummy2",
"size": 9
}
],
"continueAfter": "dummy2"
}
"""
blobs = BlobClient(http_session, 'http://example.com/')
iterable = blobs.enumerate()
iterator = iterable.__iter__()
blob_metas = []
blob_metas.append(iterator.next())
blob_metas.append(iterator.next())
http_session.get.assert_called_with(
'http://example.com/camli/enumerate-blobs')
# now set up for the second request
http_session.get = MagicMock()
response = MagicMock()
http_session.get.return_value = response
response.status_code = 200
response.content = """
{
"blobs": [
{
"blobRef": "dummy3",
"size": 17
}
]
}
"""
blob_metas.append(iterator.next())
self.assertRaises(
StopIteration,
lambda: iterator.next(),
)
self.assertEqual(
[type(x) for x in blob_metas],
[BlobMeta, BlobMeta, BlobMeta],
)
self.assertEqual(
[x.blobref for x in blob_metas],
["dummy1", "dummy2", "dummy3"],
)
self.assertEqual(
[x.size for x in blob_metas],
[5, 9, 17],
)
def test_add_mainline_kubernetes_annotations(self, m_requests):
"""
Tests add functionality using Kubernetes annotation policy driver.
"""
# Configure.
self.cni_args = "K8S_POD_NAME=podname;K8S_POD_NAMESPACE=defaultns"
workload_id = "defaultns.podname"
self.command = CNI_CMD_ADD
ip4 = "10.0.0.1/32"
ip6 = "0:0:0:0:0:ffff:a00:1"
ipam_stdout = json.dumps({"ip4": {"ip": ip4}, "ip6": {"ip": ip6}})
self.set_ipam_result(0, ipam_stdout, "")
self.policy = {"type": "k8s-annotations"}
# Set up docker client response.
inspect_result = {"HostConfig": {"NetworkMode": ""}}
self.m_docker_client().inspect_container.return_value = inspect_result
# Create plugin.
p = self.create_plugin()
assert_true(isinstance(p.container_engine, DockerEngine))
# Mock DatastoreClient such that no endpoints exist.
self.client.get_endpoint.side_effect = KeyError
# Mock profile such that it doesn't exist.
self.client.profile_exists.return_value = False
# Mock the API response.
response = MagicMock()
response.status_code = 200
api_pod = {
"kind": "pod",
"metadata": {
"annotations": {
"projectcalico.org/policy": "allow from label X=Y"
},
"labels": {
"a": "b",
"c": "d"
}
}
}
response.text = json.dumps(api_pod)
m_requests.Session().__enter__().get.return_value = response
# Execute.
p.execute()
# Assert the correct policy driver was chosen.
assert_true(isinstance(p.policy_driver, KubernetesAnnotationDriver))
# Assert an endpoint was created.
self.client.create_endpoint.assert_called_once_with(
ANY, "k8s", workload_id,
[IPNetwork(ip4), IPNetwork(ip6)])
# Assert profile was created.
self.client.create_profile.assert_called_once_with(
"defaultns_podname",
Rules(
id="defaultns_podname",
inbound_rules=[Rule(action="allow", src_tag="defaultns_X_Y")],
outbound_rules=[Rule(action="allow")]))
# Assert tags were added.
self.client.profile_update_tags.assert_called_once_with(
self.client.get_profile())
# Assert a profile was applied.
self.client.append_profiles_to_endpoint.assert_called_once_with(
profile_names=["defaultns_podname"],
endpoint_id=self.client.create_endpoint().endpoint_id)
timeout=60,
headers={"Content-type": "application/json"},
)
],
)
],
patchers=[
Patcher(target=HTTP_REQUEST, side_effect=Exception("exc_token1"))
],
)
# ------------------------------------------------
NOT_JSON_RESPONSE = MagicMock()
NOT_JSON_RESPONSE.json = MagicMock(side_effect=Exception("exc_token2"))
NOT_JSON_RESPONSE.status_code = 200
HTTP_CALL_RESP_NOT_JSON_CASE = ComponentTestCase(
name="http call response is not json case",
inputs={
"bk_http_request_method": "method_token",
"bk_http_request_url": "url_token",
"bk_http_request_body": "body_token",
"bk_http_request_header": [],
"bk_http_success_exp": "exp_token",
"bk_http_timeout": 0,
},
parent_data={},
execute_assertion=ExecuteAssertion(success=True, outputs={}),
schedule_assertion=ScheduleAssertion(success=False,
outputs={
def mock_get(url, *args, **kwargs):
if '/genomic-files/' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': {
'acl': [],
'visible': True,
'kf_id': 'GF_00000000'
}
}
return resp
elif '/genomic-files' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': [{
'acl': [],
'visible': True,
'kf_id': 'GF_00000000'
}]
}
return resp
elif '/biospecimens/' in url:
resp = MagicMock()
resp.json.return_value = {
'_links': {
'biospecimen_genomic_files': '/biospecimen-genomic-files'
'?biospecimen_id = BS_HFY3Y3XM',
'genomic_files':
'/genomic-files?biospecimen_id=BS_HFY3Y3XM'
},
'results': {
'kf_id': 'BS_HFY3Y3XM',
'dbgap_consent_code': 'phs001168.c1',
"consent_short_name": None,
'consent_type': None,
'visible': True
}
}
resp.status_code = 200
return resp
elif '/biospecimens' in url:
resp = MagicMock()
resp.json.return_value = {
'results': [{
'kf_id': 'BS_HFY3Y3XM',
'dbgap_consent_code': 'phs001168.c1',
'consent_type': None,
'visible': True,
'_links': {
'biospecimen_genomic_files':
'/biospecimen-genomic-files'
'?biospecimen_id = BS_HFY3Y3XM'
}
}]
}
resp.status_code = 200
return resp
elif '/studies' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': [{
'external_id': 'phs001168',
'version': 'v1.p1',
'kf_id': 'SD_9PYZAHHE'
}]
}
return resp
elif '/biospecimen-genomic-files' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': [{
"_links": {
"biospecimen": "/biospecimens/BS_HFY3Y3XM",
"genomic_file": "/genomic-files/GF_00000000"
},
'biospecimen_id': 'BS_HFY3Y3XM',
'genomic_file_id': 'GF_00000000'
}]
}
return resp
def check_ows(self, get, service_type, pc, invalid_content, empty_content, no_intersect_content, valid_content):
"""
Checks the status of a WFS, WCS, WMS, or WMTS service.
:param get: Patched requests.get
:param pc: ProviderCheck instance
:param invalid_content: XML representing an unrecognized response
:param empty_content: XML representing response lacking requested layer
:param no_intersect_content: XML representing response with requested layer that does not intersect AOI
:param valid_content: XML representing response with requested layer that intersects AOI
"""
# Test: cannot connect to server
get.side_effect = requests.exceptions.ConnectionError()
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.CONNECTION), result_status)
# Test: server throws SSL exception
get.side_effect = requests.exceptions.SSLError()
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.SSL_EXCEPTION), result_status)
# Test: server returns unauthorized response code
get.side_effect = None
response = MagicMock()
response.content = ""
response.status_code = 403
response.ok = False
get.return_value = response
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.UNAUTHORIZED), result_status)
# Test: server returns 404 response code
response.status_code = 404
get.return_value = response
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.NOT_FOUND), result_status)
# Test: server does not return recognizable xml
response.content = invalid_content
response.status_code = 200
response.ok = True
get.return_value = response
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.UNKNOWN_FORMAT), result_status)
if service_type not in ['wms', 'wmts']: # TODO: fix layer checks for WMS/WMTS
# Test: server does not offer the requested layer/coverage
response.content = empty_content
get.return_value = response
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.LAYER_NOT_AVAILABLE), result_status)
if service_type not in ['wms', 'wmts']: # TODO: fix layer checks for WMS/WMTS
# Test: requested layer/coverage does not intersect given AOI
response.content = no_intersect_content
get.return_value = response
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.NO_INTERSECT), result_status)
# Test: success
response.content = valid_content
get.return_value = response
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.SUCCESS), result_status)
# Test: no service_url was provided
pc.service_url = ""
result_status = json.loads(pc.check())['status']
self.assertEquals(get_status(CheckResults.NO_URL), result_status)
def get_response(self, method, url, verify, headers, data=None):
resp = MagicMock()
resp.status_code = 400
parts = urlparse(url)
url = parts[2]
params = parts[4]
if method == "GET":
if url == "/infrastructures/infid" or url == "/infrastructures/newinfid":
resp.status_code = 200
resp.json.return_value = {
"uri-list": [{
"uri": "http://server.com/infid/vms/0"
}, {
"uri": "http://server.com/infid/vms/1"
}]
}
elif url == "/infrastructures/infid/state":
resp.status_code = 200
resp.json.return_value = {
"state": {
"state": "configured",
"vm_states": {
"0": "configured",
"1": "configured"
}
}
}
elif url == "/infrastructures/infid/vms/0":
resp.status_code = 200
resp.text = "network public (outbound='yes')\n"
resp.text += "system front (net_interface.0.connection = 'public' and net_interface.0.ip = '8.8.8.8')"
elif url == "/infrastructures/infid/data":
resp.status_code = 200
resp.json.return_value = {"data": "data"}
elif url == "/infrastructures/infid/contmsg":
resp.status_code = 200
resp.text = "contmsg"
elif url == "/infrastructures/infid/radl":
resp.status_code = 200
resp.text = "network public (outbound='yes')\n"
resp.text += "system front (net_interface.0.connection = 'public' and net_interface.0.ip = '8.8.8.8')"
elif method == "POST":
if url == "/infrastructures":
resp.status_code = 200
resp.text = 'http://server.com/infid'
elif method == "PUT":
if url == "/infrastructures":
resp.status_code = 200
resp.text = 'http://server.com/newinfid'
elif url == "/infrastructures/infid/reconfigure":
resp.status_code = 200
resp.text = ''
elif url == "/infrastructures/newinfid/stop":
resp.status_code = 200
resp.text = ''
elif url == "/infrastructures/infid/start":
resp.status_code = 200
resp.text = ''
elif method == "DELETE":
if url == "/infrastructures/infid":
resp.status_code = 200
return resp
def get_response(self,
method,
url,
verify,
cert=None,
headers=None,
data=None):
resp = MagicMock()
parts = urlparse(url)
url = parts[2]
params = parts[4]
if method not in self.call_count:
self.call_count[method] = {}
if url not in self.call_count[method]:
self.call_count[method][url] = 0
self.call_count[method][url] += 1
resp.status_code = 404
if method == "GET":
if url == "":
resp.status_code = 300
resp.json.return_value = {
"versions": {
"values": [{
"id": "v3.6"
}, {
"id": "v2.0"
}]
}
}
if url == "/-/":
resp.status_code = 200
resp.text = self.read_file_as_string("files/occi.txt")
elif url == "/compute/1":
resp.status_code = 200
resp.text = self.read_file_as_string("files/occi_vm_info.txt")
elif url.startswith("/storage"):
resp.status_code = 200
resp.text = 'X-OCCI-Attribute: occi.storage.state="online"'
elif url == "/v2.0/tenants":
resp.status_code = 200
resp.json.return_value = {"tenants": [{"name": "tenantname"}]}
elif url == "/v3/auth/projects":
resp.status_code = 200
resp.json.return_value = {
"projects": [{
"id": "projectid",
"name": "prname"
}]
}
elif url == "/v3/OS-FEDERATION/identity_providers/egi.eu/protocols/oidc/auth":
resp.status_code = 200
resp.headers = {'X-Subject-Token': 'token1'}
elif url.endswith("/link/storagelink/compute_10_disk_1"):
resp.status_code = 404
elif url == "/rest/1.0/va_providers":
resp.status_code = 200
resp.text = """<appdb:appdb>
<virtualization:provider id="4454G0" in_production="true">
<provider:name>CESNET-MetaCloud</provider:name>
</virtualization:provider>
<virtualization:provider id="id" in_production="true">
<provider:name>some</provider:name>
</virtualization:provider>
</appdb:appdb>"""
elif url == "/rest/1.0/va_providers/4454G0":
resp.status_code = 200
resp.text = """<appdb:appdb>
<virtualization:provider id="4454G0" in_production="true">
<provider:endpoint_url>https://carach5.ics.muni.cz:11443</provider:endpoint_url>
<provider:image
va_provider_image_id="http://url/os_tpl#image_id"
appcname="egi.docker.ubuntu.16.04"
voname="fedcloud.egi.eu"/>
<provider:image
va_provider_image_id="http://url/os_tpl#image_id2"
appcname="egi.ubuntu.16.04"
voname="fedcloud.egi.eu"/>
</virtualization:provider>
</appdb:appdb>"""
elif url == "/network/":
resp.status_code = 200
resp.text = ("X-OCCI-Location: http://server.com/network/1"
"\nX-OCCI-Location: http://server.com/network/2")
elif url == "/network/2":
resp.status_code = 200
resp.text = "X-OCCI-Attribute: occi.network.address=\"158.42.0.0/24\""
elif url == "/network/1":
resp.status_code = 200
resp.text = "X-OCCI-Attribute: occi.network.address=\"10.0.0.0/24\""
elif method == "POST":
if url == "/compute/":
if self.return_error:
resp.status_code = 400
resp.reason = 'Error msg'
resp.text = ''
else:
resp.status_code = 201
resp.text = 'https://server.com/compute/1'
elif params == "action=suspend":
resp.status_code = 204
elif params == "action=start":
resp.status_code = 200
elif params == "action=restart":
resp.status_code = 200
elif url == "/storagelink/":
resp.status_code = 200
elif url == "/storage/":
resp.status_code = 201
resp.text = 'https://server.com/storage/1'
elif url == "/networkinterface/":
resp.status_code = 201
elif url == "/v2.0/tokens":
if json.loads(data) == {"auth": {"voms": True}}:
resp.status_code = 200
resp.json.return_value = {
"access": {
"token": {
"id": "token1"
}
}
}
elif json.loads(data) == {
"auth": {
"voms": True,
"tenantName": "tenantname"
}
}:
resp.status_code = 200
resp.json.return_value = {
"access": {
"token": {
"id": "token2"
}
}
}
else:
resp.status_code = 400
elif url == "/v3/auth/tokens":
if json.loads(data) == {
"auth": {
"scope": {
"project": {
"id": "projectid"
}
},
"identity": {
"token": {
"id": "token1"
},
"methods": ["token"]
}
}
}:
resp.status_code = 200
resp.headers = {'X-Subject-Token': 'token3'}
else:
resp.status_code = 400
elif method == "DELETE":
if url.endswith("/compute/1"):
resp.status_code = 200
elif url.endswith("/storage/1"):
resp.status_code = 200
elif url.endswith("/link/storagelink/compute_10_disk_1"):
resp.status_code = 200
elif url.endswith("/link/networkinterface/compute_10_nic_1"):
resp.status_code = 200
return resp
def get_response(self, method, url, verify, cert, headers, data):
resp = MagicMock()
parts = urlparse(url)
url = parts[2]
params = parts[4]
if method == "GET":
if url == '/info':
resp.status_code = 200
if TestDockerConnector.swarm:
resp.text = '{"Swarm": {"LocalNodeState": "active"}}'
else:
resp.text = '{"Swarm": {"LocalNodeState": "inactive"}}'
elif url == "/api/":
resp.status_code = 200
resp.text = '{"versions": "v1"}'
elif url == "/containers/1/json":
resp.status_code = 200
resp.text = '{"State": {"Running": 1}, "NetworkSettings": {"IPAddress": "10.0.0.1"}}'
elif url == "/services/1":
resp.status_code = 200
resp.text = (
'{"Spec": {"Name": "sname"},"UpdateStatus": {"CompletedAt": '
'"2016-06-07T21:10:20.269723157Z"},"Endpoint": {"VirtualIPs":'
' [{"Addr": "10.0.0.1/16"}]}}')
elif url.startswith("/tasks"):
resp.status_code = 200
resp.text = (
'[{"Status": {"State": "rejected", "Err": "Err"}}, {"Status": {"State": "running"}}]'
)
elif url.startswith("/networks"):
resp.status_code = 200
data = json.loads(params.split("=")[1])
netname = list(data['name'].keys())[0]
resp.text = '[{"Name": "%s", "Id": "netid"}]' % netname
elif method == "POST":
if url == "/containers/create":
resp.status_code = 201
resp.text = '{"Id": "id"}'
elif url == "/services/create":
resp.status_code = 201
resp.text = '{"ID": "id"}'
elif url == "/images/create":
resp.status_code = 200
elif url.endswith("/start"):
resp.status_code = 204
elif url.endswith("/stop"):
resp.status_code = 204
elif url.endswith("/restart"):
resp.status_code = 204
elif url == "/volumes/create":
resp.status_code = 201
elif url == "/networks/create":
resp.status_code = 201
elif url == "/networks/netid/connect":
resp.status_code = 200
elif method == "DELETE":
if url == "/containers/1":
resp.status_code = 204
if url == "/services/1":
resp.status_code = 200
if url == "/volumes/hdb":
resp.status_code = 204
if url == "/networks/netid":
resp.status_code = 204
return resp
def test_create(event):
""" Test that the lamba calls the dataservice """
os.environ['DATASERVICE'] = 'http://api.com/'
mock = patch('service.requests')
req = mock.start()
class Context:
def get_remaining_time_in_millis(self):
return 1600
def mock_get(url, *args, **kwargs):
if '/genomic-files/' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': {
'acl': [],
'visible': True,
'kf_id': 'GF_00000000'
}
}
return resp
elif '/genomic-files' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': [{
'acl': [],
'visible': True,
'kf_id': 'GF_00000000'
}]
}
return resp
elif '/biospecimens/' in url:
resp = MagicMock()
resp.json.return_value = {
'_links': {
'biospecimen_genomic_files': '/biospecimen-genomic-files'
'?biospecimen_id = BS_HFY3Y3XM',
'genomic_files':
'/genomic-files?biospecimen_id=BS_HFY3Y3XM'
},
'results': {
'kf_id': 'BS_HFY3Y3XM',
'dbgap_consent_code': 'phs001168.c1',
"consent_short_name": None,
'consent_type': None,
'visible': True
}
}
resp.status_code = 200
return resp
elif '/biospecimens' in url:
resp = MagicMock()
resp.json.return_value = {
'results': [{
'kf_id': 'BS_HFY3Y3XM',
'dbgap_consent_code': 'phs001168.c1',
'consent_type': None,
'visible': True,
'_links': {
'biospecimen_genomic_files':
'/biospecimen-genomic-files'
'?biospecimen_id = BS_HFY3Y3XM'
}
}]
}
resp.status_code = 200
return resp
elif '/studies' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': [{
'external_id': 'phs001168',
'version': 'v1.p1',
'kf_id': 'SD_9PYZAHHE'
}]
}
return resp
elif '/biospecimen-genomic-files' in url:
resp = MagicMock()
resp.status_code = 200
resp.json.return_value = {
'results': [{
"_links": {
"biospecimen": "/biospecimens/BS_HFY3Y3XM",
"genomic_file": "/genomic-files/GF_00000000"
},
'biospecimen_id': 'BS_HFY3Y3XM',
'genomic_file_id': 'GF_00000000'
}]
}
return resp
req.get.side_effect = mock_get
req.patch.side_effect = mock_get
mock_resp = MagicMock()
mock_resp.json.return_value = {'results': {'kf_id': 'GF_00000000'}}
mock_resp.status_code = 201
req.post.return_value = mock_resp
req.patch.return_value = mock_resp
res = service.handler(event, Context())
assert len(res) == 1
def mocked_request(self, verb):
response = MagicMock()
response.status_code = 201
response.json = MagicMock(return_value={})
with patch.object(requests, verb, return_value=response) as mocked:
yield mocked
def get_response(self, method, url, verify, cert, headers, data):
resp = MagicMock()
parts = uriparse(url)
url = parts[2]
# params = parts[4]
if method == "GET":
if url == '/info':
resp.status_code = 200
if self.swarm:
resp.text = '{"Swarm": {"LocalNodeState": "active"}}'
else:
resp.text = '{"Swarm": {"LocalNodeState": "inactive"}}'
elif url == "/api/":
resp.status_code = 200
resp.text = '{"versions": "v1"}'
elif url == "/containers/1/json":
resp.status_code = 200
resp.text = '{"State": {"Running": 1}, "NetworkSettings": {"IPAddress": "10.0.0.1"}}'
elif url == "/services/1":
resp.status_code = 200
resp.text = (
'{"UpdateStatus": {"CompletedAt": "2016-06-07T21:10:20.269723157Z"},'
'"Endpoint": {"VirtualIPs": [{"Addr": "10.0.0.1/16"}]}}')
elif url.startswith("/tasks?filters"):
resp.status_code = 200
resp.text = (
'[{"Status": {"State": "rejected", "Err": "Err"}}, {"Status": {"State": "running"}}]'
)
elif method == "POST":
if url == "/containers/create":
resp.status_code = 201
resp.text = '{"Id": "id"}'
elif url == "/services/create":
resp.status_code = 201
resp.text = '{"ID": "id"}'
elif url == "/images/create":
resp.status_code = 200
elif url.endswith("/start"):
resp.status_code = 204
elif url.endswith("/stop"):
resp.status_code = 204
elif url == "/volumes/create":
resp.status_code = 201
elif url == "/networks/create":
resp.status_code = 201
elif method == "DELETE":
if url.endswith("/containers/1"):
resp.status_code = 204
if url.endswith("/servicess/1"):
resp.status_code = 200
return resp
def test_get_task_status(self, utils_mock, authenticate_mock, config_mock):
# Mocking self.authenticate() method
authenticate_mock.return_value = 200
config_mock.side_effect = mock_get_config
response_instance = MagicMock()
response_instance.status_code = 200
return_data = {
'ManagedResourceID':
'9f92203e-313c-4b35-88ff-ff00a9d77153',
'ParentTaskId':
None,
'TenantID':
'9f92203e-313c-4b35-88ff-ff00a9d77153',
'CreatedDate':
'2018-06-22T05:28:19.777Z',
'SessionID':
None,
'EditedBy':
'test@hostname',
'PortalUserName':
'******',
'MessageName':
'SetVM',
'TaskInfoID':
'c22135d9-5931-4aff-8462-e6601c5b573b',
'LocalizableError':
None,
'CreatedBy':
'test@hostname',
'ManagedResourceName':
'qqqqqq',
'Errors':
None,
'TaskName':
'Provisioning VM qqqqqq',
'Progress':
1,
'Cancellable':
False,
'StateMessage':
'Success',
'StartTime':
'2018-06-22T05:28:19.777Z',
'CorrelationId':
'c22135d9-5931-4aff-8462-e6601c5b573b',
'Result':
None,
'EditedDate':
'2018-06-22T05:28:20.919Z',
'ManagedResourceIdentifier':
None,
'ManagedResourceType':
'Tenant',
'CustomerId':
0,
'TaskId':
'c22135d9-5931-4aff-8462-e6601c5b573b',
'SiteID':
'69d29e4b-ce66-66b9-a07d-c4612616bb0f',
'FinishTime':
None,
'HypervisorID':
None,
'UserName':
'******',
'Acl': [{
'ResourceRole': '3f9d5bf4-0f63-4ede-8a31-f832af8dc07b',
'UserGroup': '77922643-80cb-7eb5-d6ca-6c21327b6d11',
'Permissions': 1
}, {
'ResourceRole': '3985741b-0df2-4e9a-869b-46369842b0da',
'UserGroup': 'b742a2b9-2063-f1b0-b831-40aa5d39234e',
'Permissions': 1
}, {
'ResourceRole': '3f9d5bf4-0f63-4ede-8a31-f832af8dc07b',
'UserGroup': '84e201ba-a318-46a9-abec-65c801d76477',
'Permissions': 1
}, {
'ResourceRole': '3f9d5bf4-0f63-4ede-8a31-f832af8dc07b',
'UserGroup': '2819972e-7be9-4d7c-a809-cd1c6a1baf86',
'Permissions': 1
}],
'State':
3
}
match_data = {'vm_id': None, 'state': 'Success'}
response_instance.json.return_value = return_data
utils_mock.make_get_request.return_value = response_instance
self.platforma = PlatformAManager()
with patch('iaas.platforma.sleep'):
parameter_dict = {"message_id": "123s-3fs32-svseves-43sefsef"}
msg_info = self.platforma.get_task_status(
parameters=parameter_dict)
self.assertEqual(msg_info, match_data)
def test_fail_request(self):
with patch('requests.post') as mock_post:
response = MagicMock()
response.status_code = 201
with pytest.raises(FailedRequest):
self.auth.call_post('url', {})
def test_make_request(self, method, headers, data, response_status):
url = 'http://example.com'
ERROR_MSG = 'This is an example error!'
# Set the environ
usertoken = store_connector.plugins.toolkit.c.usertoken = {
'token_type': 'bearer',
'access_token': 'access_token',
'refresh_token': 'refresh_token'
}
newtoken = {
'token_type': 'bearer',
'access_token': 'new_access_token',
'refresh_token': 'new_refresh_token'
}
# Mock refresh_function
def refresh_function_side_effect():
store_connector.plugins.toolkit.c.usertoken = newtoken
store_connector.plugins.toolkit.c.usertoken_refresh = MagicMock(
side_effect=refresh_function_side_effect)
expected_headers = headers.copy()
expected_headers['Accept'] = 'application/json'
# Set the response status
first_response = MagicMock()
first_response.status_code = response_status
first_response.text = '{"message": %s, "result": False}' % ERROR_MSG
second_response = MagicMock()
second_response.status_code = 201
request = MagicMock()
store_connector.OAuth2Session = MagicMock(return_value=request)
req_method = MagicMock(side_effect=[first_response, second_response])
setattr(request, method, req_method)
# Call the function
if response_status > 399 and response_status < 600 and response_status != 401:
with self.assertRaises(Exception) as e:
self.instance._make_request(method, url, headers, data)
self.assertEquals(ERROR_MSG, e.message)
store_connector.OAuth2Session.assert_called_once_with(
token=usertoken)
req_method.assert_called_once_with(url,
headers=expected_headers,
json=data)
else:
result = self.instance._make_request(method, url, headers, data)
# If the first request returns a 401, the request is retried with a new access_token...
if response_status != 401:
self.assertEquals(first_response, result)
req_method.assert_called_once_with(url,
headers=expected_headers,
json=data,
verify=True)
store_connector.OAuth2Session.assert_called_once_with(
token=usertoken)
req_method.assert_called_once_with(url,
headers=expected_headers,
json=data,
verify=True)
else:
# Check that the token has been refreshed
store_connector.plugins.toolkit.c.usertoken_refresh.assert_called_once_with(
)
# Check that both tokens has been used
self.assertEquals(
usertoken, store_connector.OAuth2Session.call_args_list[0]
[1]['token'])
self.assertEquals(
newtoken, store_connector.OAuth2Session.call_args_list[1]
[1]['token'])
# Check URL
self.assertEquals(url, req_method.call_args_list[0][0][0])
self.assertEquals(url, req_method.call_args_list[1][0][0])
# Check headers
self.assertEquals(expected_headers,
req_method.call_args_list[0][1]['headers'])
self.assertEquals(expected_headers,
req_method.call_args_list[1][1]['headers'])
# Check Data
self.assertEquals(data,
req_method.call_args_list[0][1]['json'])
self.assertEquals(data,
req_method.call_args_list[1][1]['json'])
# Check response
self.assertEquals(second_response, result)
def get(url):
result = self._response
if url == "http://producturl.com/":
result = MagicMock()
result.status_code = 404
return result
def mocked_request_setup():
r_return = MagicMock()
r_return.status_code = 200
r_return.content = {'dcos_token': 'foobar'}
return r_return
import sys
from mock import patch, MagicMock
from indicoio.utils import is_url
mock_response = MagicMock()
mock_response.headers = {'x-warning': 'testing warning'}
mock_response.status_code = 200
mock_response.json = MagicMock(return_value={'results': 0.5})
def test_is_urls():
boring_image = [0] * (32**2)
boring_images = [boring_image] * 100
assert not is_url(boring_image, batch=False)
assert not is_url(boring_images, batch=True)
url = 'http://picturepicture.com/picture'
urls = [url] * 100
assert is_url(url, batch=False)
assert is_url(urls, batch=True)
@patch('indicoio.utils.api.warnings.warn')
@patch('indicoio.utils.api.requests.post',
MagicMock(return_value=mock_response))
def test_api_handler(mock_warn):
from indicoio.utils.api import api_handler
def test_partial_content(self):
response = MagicMock()
response.status_code = 206
actual = _translate_errors(lambda: response)
self.assertTrue(response is actual) # no assertIs until 2.7
def test_b2_error(self):
response = MagicMock()
response.status_code = 503
response.content = b'{"status": 503, "code": "server_busy", "message": "busy"}'
with self.assertRaises(ServiceError):
_translate_errors(lambda: response)
def get_response(url, params=None, **kwargs):
resp = MagicMock()
parts = urlparse(url)
url = parts[2]
params = parts[4]
resp.status_code = 404
resp.ok = False
if url == "/im/infrastructures":
resp.ok = True
resp.status_code = 200
resp.json.return_value = {
"uri-list": [{
"uri":
"http://server.com/im/infrastructures/infid"
}]
}
elif url == "/im/infrastructures/infid/state":
resp.ok = True
resp.status_code = 200
resp.json.return_value = {
"state": {
"state": "configured",
"vm_states": {
"0": "configured"
}
}
}
elif url == "/im/infrastructures/infid/vms/0":
resp.ok = True
resp.status_code = 200
resp.text = ""
radl = {
"class": "system",
"cpu.arch": "x86_64",
"cpu.count_min": 1,
"disk.0.image.url": "one://server.com/id",
"disk.0.os.name": "linux",
"id": "front",
"state": "configured",
"disk.0.os.credentials.username": "******",
"disk.0.os.credentials.password": "******",
"memory.size_min": 536870912,
"net_interface.0.connection": "publica",
"net_interface.0.ip": "10.10.10.10",
"provider.type": "OpenNebula",
"provider.host": "server.com"
}
resp.json.return_value = {"radl": [radl]}
elif url == "/im/infrastructures/infid/vms/0/stop":
resp.ok = True
resp.status_code = 200
elif url == "/im/infrastructures/infid/tosca":
resp.ok = True
resp.status_code = 200
resp.text = "TOSCA"
elif url == "/im/infrastructures/infid/contmsg":
resp.ok = True
resp.status_code = 200
resp.text = "CONT_MSG"
elif url == "/im/infrastructures/infid/vms/0/contmsg":
resp.ok = True
resp.status_code = 200
resp.text = "VM_CONT_MSG"
elif url == "/im/infrastructures/infid/outputs":
resp.ok = True
resp.status_code = 200
resp.json.return_value = {
"outputs": {
"key": "value",
"key2": "http://server.com"
}
}
elif url == "/im/infrastructures/infid/radl":
resp.ok = True
resp.status_code = 200
resp.text = "system wn ()\nsystem front ()"
return resp
def get_response(self, method, url, verify, cert, headers, data):
resp = MagicMock()
parts = uriparse(url)
url = parts[2]
params = parts[4]
if method not in self.call_count:
self.call_count[method] = {}
if url not in self.call_count[method]:
self.call_count[method][url] = 0
self.call_count[method][url] += 1
if method == "GET":
if url == "":
resp.status_code = 300
resp.json.return_value = {
"versions": {
"values": [{
"id": "v3.6"
}, {
"id": "v2.0"
}]
}
}
if url == "/-/":
resp.status_code = 200
resp.text = read_file_as_string("files/occi.txt")
elif url == "/compute/1":
resp.status_code = 200
resp.text = read_file_as_string("files/occi_vm_info.txt")
elif url.startswith("/storage"):
resp.status_code = 200
resp.text = 'X-OCCI-Attribute: occi.storage.state="online"'
elif url == "/v2.0/tenants":
resp.status_code = 200
resp.json.return_value = {"tenants": [{"name": "tenantname"}]}
elif url == "/v3/auth/projects":
resp.status_code = 200
resp.json.return_value = {
"projects": [{
"id": "projectid",
"name": "prname"
}]
}
elif url == "/v3/OS-FEDERATION/identity_providers/egi.eu/protocols/oidc/auth":
resp.status_code = 200
resp.headers = {'X-Subject-Token': 'token1'}
elif url.endswith("/link/storagelink/compute_10_disk_1"):
resp.status_code = 404
elif method == "POST":
if url == "/compute/":
if self.return_error:
resp.status_code = 400
resp.reason = 'Error msg'
resp.text = ''
else:
resp.status_code = 201
resp.text = 'https://server.com/compute/1'
elif params == "action=suspend":
resp.status_code = 204
elif params == "action=start":
resp.status_code = 200
elif url == "/storagelink/":
resp.status_code = 200
elif url == "/storage/":
resp.status_code = 201
resp.text = 'https://server.com/storage/1'
elif url == "/networkinterface/":
resp.status_code = 201
elif url == "/v2.0/tokens":
if json.loads(data) == {"auth": {"voms": True}}:
resp.status_code = 200
resp.json.return_value = {
"access": {
"token": {
"id": "token1"
}
}
}
elif json.loads(data) == {
"auth": {
"voms": True,
"tenantName": "tenantname"
}
}:
resp.status_code = 200
resp.json.return_value = {
"access": {
"token": {
"id": "token2"
}
}
}
else:
resp.status_code = 400
elif url == "/v3/auth/tokens":
if json.loads(data) == {
"auth": {
"scope": {
"project": {
"id": "projectid"
}
},
"identity": {
"token": {
"id": "token1"
},
"methods": ["token"]
}
}
}:
resp.status_code = 200
resp.headers = {'X-Subject-Token': 'token3'}
else:
resp.status_code = 400
elif method == "DELETE":
if url.endswith("/compute/1"):
resp.status_code = 200
elif url.endswith("/storage/1"):
resp.status_code = 200
elif url.endswith("/link/storagelink/compute_10_disk_1"):
resp.status_code = 200
elif url.endswith("/link/networkinterface/compute_10_nic_1"):
resp.status_code = 200
return resp
def get_response(self, method, url, verify, headers={}, data=None):
resp = MagicMock()
parts = urlparse(url)
url = parts[2]
params = parts[4]
if method not in self.call_count:
self.call_count[method] = {}
if url not in self.call_count[method]:
self.call_count[method][url] = 0
self.call_count[method][url] += 1
resp.status_code = 400
if method == "GET":
if url == "/computes/1":
resp.status_code = 200
resp.json.return_value = {
"disk": 0,
"hostName": "hostname",
"id": "1",
"ipAddresses": ["10.0.0.1"],
"memory": 1024,
"state": "READY",
"vCPU": 1
}
elif url == "/volumes/1":
resp.status_code = 200
resp.json.return_value = {
"id": "1",
"name": "volname",
"size": 1,
"state": "READY"
}
elif url == "/networks/status":
resp.status_code = 200
resp.json.return_value = [{
"instanceId": "1",
"instanceName": "netname",
"state": "READY"
}]
elif url == "/federatedNetworks/status":
resp.status_code = 200
resp.json.return_value = [{
"instanceId": "1",
"instanceName": "fednetname",
"state": "READY"
}]
elif url == "/federatedNetworks/1":
resp.status_code = 200
resp.json.return_value = {
"instanceId": "1",
"cidr": "10.0.1.0/24"
}
elif url == "/publicIps/status":
resp.status_code = 200
resp.json.return_value = [{
"instanceId": "1",
"instanceName": "ipname",
"state": "READY"
}]
elif url == "/publicIps/1":
resp.status_code = 200
resp.json.return_value = {
"id": "1",
"ip": "8.8.8.8",
"computeId": "1",
"state": "READY"
}
elif url == "/networks/1":
resp.status_code = 200
resp.json.return_value = {
"id": "1",
"name": "netname",
"cidr": "192.168.0.0/24",
"gateway": "192.168.0.1",
"allocation": "dynamic",
"state": "READY"
}
elif url == "/attachments/1":
resp.status_code = 200
resp.json.return_value = {
"id": "1",
"serverId": "1",
"volumeId": "1",
"device": "/dev/sdb",
"state": "READY"
}
elif url == "/publicKey/":
resp.status_code = 200
resp.json.return_value = {"publicKey": "publicKey"}
elif url == "/publicIps/1/securityRules":
resp.status_code = 200
resp.json.return_value = []
elif url == "/networks/1/securityRules":
resp.status_code = 200
resp.json.return_value = []
elif method == "POST":
if url == "/computes/":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "/publicIps/":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "/volumes/":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "/attachments/":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "/networks/":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "server1.com/tokens/":
resp.status_code = 201
resp.json.return_value = {"token": "token"}
elif url == "/federatedNetworks/":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "/publicIps/1/securityRules":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif url == "/networks/1/securityRules":
resp.status_code = 201
resp.json.return_value = {"id": "1"}
elif method == "DELETE":
if url == "/computes/1":
resp.status_code = 204
elif url == "/volumes/1":
resp.status_code = 204
elif url == "/networks/1":
resp.status_code = 204
elif url == "/publicIps/1":
resp.status_code = 204
elif url == "/attachments/1":
resp.status_code = 204
elif method == "HEAD":
if url == "/clouds/":
resp.status_code = 200
return resp
def test_check_oidc_invalid_token(self, request):
im_auth = {"token": self.gen_token()}
Config.OIDC_ISSUERS = ["https://iam-test.indigo-datacloud.eu/"]
with self.assertRaises(Exception) as ex:
IM.check_oidc_token(im_auth)
self.assertEqual(
str(ex.exception),
'Invalid InfrastructureManager credentials. OIDC auth Token expired.'
)
im_auth_aud = {"token": self.gen_token(aud="test1,test2")}
Config.OIDC_AUDIENCE = "test"
with self.assertRaises(Exception) as ex:
IM.check_oidc_token(im_auth_aud)
self.assertEqual(
str(ex.exception),
'Invalid InfrastructureManager credentials. Audience not accepted.'
)
Config.OIDC_AUDIENCE = "test2"
with self.assertRaises(Exception) as ex:
IM.check_oidc_token(im_auth_aud)
self.assertEqual(
str(ex.exception),
'Invalid InfrastructureManager credentials. OIDC auth Token expired.'
)
Config.OIDC_AUDIENCE = None
Config.OIDC_SCOPES = ["scope1", "scope2"]
Config.OIDC_CLIENT_ID = "client"
Config.OIDC_CLIENT_SECRET = "secret"
response = MagicMock()
response.status_code = 200
response.text = '{ "scope": "profile scope1" }'
request.return_value = response
with self.assertRaises(Exception) as ex:
IM.check_oidc_token(im_auth_aud)
self.assertEqual(
str(ex.exception), 'Invalid InfrastructureManager credentials. '
'Scopes scope1 scope2 not in introspection scopes: profile scope1')
response.status_code = 200
response.text = '{ "scope": "address profile scope1 scope2" }'
request.return_value = response
with self.assertRaises(Exception) as ex:
IM.check_oidc_token(im_auth_aud)
self.assertEqual(
str(ex.exception), 'Invalid InfrastructureManager credentials. '
'OIDC auth Token expired.')
Config.OIDC_SCOPES = []
Config.OIDC_CLIENT_ID = None
Config.OIDC_CLIENT_SECRET = None
Config.OIDC_ISSUERS = ["https://other_issuer"]
with self.assertRaises(Exception) as ex:
IM.check_oidc_token(im_auth)
self.assertEqual(
str(ex.exception),
"Invalid InfrastructureManager credentials. Issuer not accepted.")
