def test_upload_app_poll_status(self):
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/'
}
response_not_completed = Response()
response_not_completed.status_code = 200
response_not_completed.encoding = 'utf-8'
response_not_completed._content = json.dumps(
{'completed': False, 'application_url': ''}).encode('utf-8')
response_completed = Response()
response_completed.status_code = 200
response_completed.encoding = 'utf-8'
response_completed._content = json.dumps(
{'completed': True, 'revision': 14,
'application_url': 'http://example.org'}).encode('utf-8')
self.mock_get.side_effect = [
response_not_completed,
response_not_completed,
response_completed,
]
response = upload_app(self.package_name, self.data)
self.assertEqual(response, {
'success': True,
'errors': [],
'application_url': 'http://example.org',
'revision': 14,
})
self.assertEqual(self.mock_get.call_count, 3)
def test_avi_json(self):
rsp = Response()
rsp.status_code = 404
rsp._content = 'Not found'
try:
avi_rsp = ApiResponse(rsp)
avi_rsp.json()
assert False
except ObjectNotFound:
pass
except Exception:
assert False
rsp.status_code = 501
try:
avi_rsp = ApiResponse(rsp)
avi_rsp.json()
assert False
except APIError:
pass
except Exception:
assert False
rsp.status_code = 200
rsp._content = json.dumps({'count': 3, 'results': ['a', 'b', 'c']})
try:
avi_rsp = ApiResponse(rsp)
obj = avi_rsp.json()
assert obj['count']
assert avi_rsp.count() == 3
assert len(obj['results']) == 3
except Exception as e:
log.debug('exception %s', str(e))
log.debug('%s', traceback.format_exc())
assert False
def test_should_contain1(self, requests):
response = Response()
response.status_code = 200
response._content = """
<CFRDOC>
<AMDDATE>Jan 1, 2001</AMDDATE>
<PARTS>Part 111 to 222</PARTS>
</CFRDOC>"""
response._content_consumed = True
requests.get.return_value = response
volume = annual.Volume(2001, 12, 2)
self.assertFalse(volume.should_contain(1))
self.assertFalse(volume.should_contain(100))
self.assertFalse(volume.should_contain(300))
self.assertFalse(volume.should_contain(250))
self.assertTrue(volume.should_contain(111))
self.assertTrue(volume.should_contain(211))
self.assertTrue(volume.should_contain(222))
response._content = """
<CFRDOC>
<AMDDATE>Jan 1, 2001</AMDDATE>
<PARTS>Parts 587 to End</PARTS>
</CFRDOC>"""
response._content_consumed = True
volume = annual.Volume(2001, 12, 2)
self.assertFalse(volume.should_contain(111))
self.assertFalse(volume.should_contain(586))
self.assertTrue(volume.should_contain(587))
self.assertTrue(volume.should_contain(600))
self.assertTrue(volume.should_contain(999999))
def test_delete_operation():
response = Response()
response._content = '{"access_token":"CLIENT_ACCESS_TOKEN","token_type":"Bearer","expires_in":3887999}'
requests.post = MagicMock(return_value=response)
auth = APIManager('CLIENT_ID', 'CLIENT_SECRET', 'HOSTNAME')
response = Response()
response._content = '{"message": "SUCCESS"}'
requests.delete = MagicMock(return_value=response)
delete = auth.delete('ROUTE')
assert delete.content == '{"message": "SUCCESS"}'
def test_authenticate_decorator():
response = Response()
response._content = '{"access_token":"ACCESS_TOKEN","token_type":"Bearer","expires_in":-5}'
requests.post = MagicMock(return_value=response)
auth = APIManager('CLIENT_ID', 'CLIENT_SECRET', 'HOSTNAME')
assert auth.access_token['access_token'] == 'ACCESS_TOKEN'
response._content = '{"access_token":"REFRESHED_ACCESS_TOKEN","token_type":"Bearer","expires_in":3887999}'
auth.post('/')
assert auth.access_token['access_token'] == 'REFRESHED_ACCESS_TOKEN'
def request(self, url, method, **kwargs):
resp = Response()
if url == '/role_assignments?scope.domain.id=default':
json_data = open(UNIT_TEST_RESOURCES_FOLDER + LIST_ROLE_ASSIGNMENTS_RESPONSE_FILE_EXTENDED1).read()
resp.status_code = OK
resp._content = json_data
elif url == '/role_assignments?user.id=fake3&scope.domain.id=default':
json_data = open(UNIT_TEST_RESOURCES_FOLDER + LIST_USERS_RESPONSE_FILE2).read()
resp.status_code = OK
resp._content = json_data
return resp
def mock_response():
global HIT_COUNT
HIT_COUNT += 1
r = Response()
r.status_code = 200
if HIT_COUNT == 1:
with open("app/ciscoeox/tests/data/cisco_eox_response_page_1_of_2.json") as f:
r._content = f.read().encode("utf-8")
else:
with open("app/ciscoeox/tests/data/cisco_eox_response_page_2_of_2.json") as f:
r._content = f.read().encode("utf-8")
return r
def _request(method, url, *args, **kwargs):
assert method == 'GET'
assert url == 'http://localhost:123/collection.txt'
r = Response()
r.status_code = 200
try:
with open(self.tmpfile, 'rb') as f:
r._content = f.read()
except IOError:
r._content = b''
r.headers['Content-Type'] = 'text/icalendar'
r.encoding = 'ISO-8859-1'
return r
def _request(method, url, *args, **kwargs):
assert method == 'GET'
assert url == 'http://localhost:123/collection.txt'
assert 'vdirsyncer' in kwargs['headers']['User-Agent']
r = Response()
r.status_code = 200
try:
with open(self.tmpfile, 'rb') as f:
r._content = f.read()
except IOError:
r._content = b''
r.headers['Content-Type'] = 'text/calendar'
r.encoding = 'utf-8'
return r
def test_run_tests(self):
rainforest = Rainforest('CLIENT_TOKEN')
# Validate that the potential for an invalid client token raises an exception
mocked_response = Response()
mocked_response.status_code = 404
mocked_response._content = '{"error":"Account not found"}'
requests.post = Mock(return_value=mocked_response)
with self.assertRaises(RainforestError):
rainforest.run_tests([1,2,3])
# Validate that the potential for an invalid client token raises an exception
mocked_response = Response()
mocked_response.status_code = 400
mocked_response._content = '{"error":"You must specify the tags or tests parameter"}'
requests.post = Mock(return_value=mocked_response)
with self.assertRaises(RainforestError):
rainforest.run_tests(["a","b","c"])
# Validate that tests get returned properly on a successful case
mocked_response = Response()
mocked_response.status_code = 201
mocked_response._content = '{"id":1,"object":"Run","created_at":"2014-04-19T06:06:47Z","environment_id":1770,"state_log":[],"state":"queued","result":"no_result","expected_wait_time":8100.0,"browsers":[{"name":"chrome","state":"disabled"},{"name":"firefox","state":"disabled"},{"name":"ie8","state":"disabled"},{"name":"ie9","state":"disabled"},{"name":"safari","state":"disabled"}],"requested_tests":[1,2,3]}'
requests.post = Mock(return_value=mocked_response)
test_run = rainforest.run_tests([1,2,3])
requests.post.assert_called_with('https://app.rainforestqa.com/api/1/runs', data='{"tests": [1, 2, 3]}', headers={
'Content-Type' : 'application/json',
'Accept' : 'application/json',
'CLIENT_TOKEN' : 'CLIENT_TOKEN',
})
self.assertIsInstance(test_run, TestRun)
self.assertEqual(test_run.id, 1)
self.assertEqual(test_run.object, 'Run')
self.assertEqual(test_run.created_at, '2014-04-19T06:06:47Z')
self.assertEqual(test_run.environment_id, 1770)
self.assertEqual(test_run.state, 'queued')
self.assertEqual(test_run.result, 'no_result')
self.assertEqual(test_run.expected_wait_time, 8100.0)
self.assertEqual(test_run.browsers, [{"name":"chrome","state":"disabled"},{"name":"firefox","state":"disabled"},{"name":"ie8","state":"disabled"},{"name":"ie9","state":"disabled"},{"name":"safari","state":"disabled"}])
self.assertEqual(test_run.requested_tests, [1,2,3])
def test_yahoo_get_by_date(yahoo, logger):
sample = Response()
sample.status_code = 200
sample._content = YAHOO_RESPONSE
yahoo._get = lambda *a, **kw: sample
assert yahoo.get_by_date(date.today(), "CZK", logger) == Decimal("25.959")
def create_response(**kw):
r = Response()
r._content = b''
r.status = 200
for k, v in kw.items():
setattr(r, k, v)
return r
def responses(code, path=None, redirection=None, data=None,
url=None,
headers=None):
if headers is None:
headers = {'Content-Type': 'text/xml'}
response = Response()
response.status_code = code
if path is not None and redirection is None:
with open(data_file(path), 'rb') as f:
response.raw = BytesIO(f.read())
elif data is not None:
response._content = data.encode('utf-8')
if redirection is not None:
temp = Response()
temp.status_code = 301 if 'permanent' in redirection else 302
temp.url = path
response.history.append(temp)
response.url = redirection
headers['location'] = path
if url is None:
if redirection is not None:
url = redirection
else:
url = 'https://example.com/{}'.format(str(uuid4()))
response.url = url
response.headers = headers
return response
def test_keystone_client_exception(self, logger):
"""
``keystoneclient.openstack.common.apiclient.exceptions.BadRequest`` is
treated similarly to ``novaclient.exceptions.ClientException``.
See ``test_novaclient_exception``.
"""
response = Response()
response._content = "hello world"
result = KeystoneHttpError(
message="Some things went wrong with some other things.",
details={"key": "value"},
response=response,
request_id="abcdefghijklmnopqrstuvwxyz",
url="/foo/bar",
method="POST",
http_status=INTERNAL_SERVER_ERROR,
)
logging_dummy = LoggingDummy(Dummy(result))
self.assertRaises(KeystoneHttpError, logging_dummy.raise_method)
logged = LoggedMessage.of_type(
logger.messages, KEYSTONE_HTTP_ERROR,
)[0]
assertContainsFields(
self, logged.message, {
u"code": result.http_status,
u"message": result.message,
u"details": result.details,
u"request_id": result.request_id,
u"url": result.url,
u"method": result.method,
u"response": "hello world",
},
)
def test_cutout_get_success(self, mock_session):
resolution = 0
x_range = '20:40'
y_range = '50:70'
z_range = '30:50'
time_range = '10:25'
url_prefix = 'https://api.theboss.io'
auth = 'mytoken'
fake_prepped_req = PreparedRequest()
fake_prepped_req.headers = {}
mock_session.prepare_request.return_value = fake_prepped_req
data = numpy.random.randint(0, 3000, (15, 20, 20, 20), numpy.uint16)
compressed_data = blosc.pack_array(data)
fake_response = Response()
fake_response.status_code = 200
fake_response._content = compressed_data
mock_session.send.return_value = fake_response
send_opts = {}
actual = self.vol.cutout_get(
self.chan, resolution, x_range, y_range, z_range, time_range,
url_prefix, auth, mock_session, send_opts)
numpy.testing.assert_array_equal(data, actual)
def logged_in(self, login='******', travis_user=True):
""" A context manager to do stuff, while logged in as fred. """
response = Response()
response._content = json.dumps(
dict(id=12345, login=login, name='Fred')
)
data = Mock()
data.get = Mock(return_value=response)
data.access_token = GH_TOKEN
true = Mock(return_value=True)
if travis_user:
travis_patch = patch('travis_utils.is_travis_user', true)
travis_patch.start()
with patch('statiki.github', Mock(spec=OAuth2Service)) as gh:
gh.get_auth_session = Mock(return_value=data)
try:
yield self.app.get('/authorized?code="bazooka"')
finally:
if travis_user:
travis_patch.stop()
self.app.get('/logout')
def stub(url):
response = Response()
response._content = json
response.url = url
response.status_code = status_code
response.json = json_loads_stub(json)
return response
def _method(self, url, *args, **kwargs):
success = url in self.urls
content = self.urls.get(url, '')
resp = Response()
resp._content = content.encode('utf-8')
resp.status_code = codes.ok if success else codes.not_found
return resp
def test_download_fails_due_to_hash_mismatch(self):
snap_content = b'1234567890'
mock_details = self.mock_get.return_value
mock_details.ok = True
mock_details.content = json.dumps({
'_embedded': {
'clickindex:package': [{
'download_url': 'http://localhost',
'anon_download_url': 'http://localhost',
'download_sha512': '12345',
}],
}
}).encode('utf-8')
mock_snap = Response()
mock_snap.status_code = 200
mock_snap._content = snap_content
self.mock_get.side_effect = [mock_details, mock_snap]
with self.assertRaises(RuntimeError) as raised:
download('os', 'edge', 'os.snap', None, 'amd64')
self.assertEqual("Failed to download 'os'", str(raised.exception))
self.mock_logger.info.assert_has_calls([
call("Getting details for 'os'"),
call("Downloading 'os'")])
self.assertTrue(os.path.exists('os.snap'))
def fake_response_handler(url=None, **kwargs):
r = Response()
r.status_code = 200
r.encoding = "utf-8"
assert url in fake_responses, "unknown URL: " + url
r._content = fake_responses[url]
return r
def test_download_redownload_as_hash_mismatches(self):
with open('os.snap', 'wb') as f:
f.write(b'0000000')
snap_content = b'1234567890'
snap_sha512 = ('12b03226a6d8be9c6e8cd5e55dc6c7920caaa39df14aab92d5e'
'3ea9340d1c8a4d3d0b8e4314f1f6ef131ba4bf1ceb9186ab87c'
'801af0d5c95b1befb8cedae2b9')
mock_details = self.mock_get.return_value
mock_details.ok = True
mock_details.content = json.dumps({
'_embedded': {
'clickindex:package': [{
'download_url': 'http://localhost',
'anon_download_url': 'http://localhost',
'download_sha512': snap_sha512,
}],
}
}).encode('utf-8')
mock_snap = Response()
mock_snap.status_code = 200
mock_snap._content = snap_content
self.mock_get.side_effect = [mock_details, mock_snap]
download('os', 'edge', 'os.snap', None, 'amd64')
self.mock_logger.info.assert_has_calls([
call("Getting details for 'os'"),
call("Downloading 'os'"),
call("Successfully downloaded 'os'")])
self.assertTrue(os.path.exists('os.snap'))
def test_upload_app_ok(self):
# fake upload response
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
# fake poll status response
application_url = 'http://example.com/app/1'
revision = '1'
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps(
{'completed': True, 'revision': revision,
'application_url': application_url}).encode('utf-8')
self.mock_get.return_value = ok_response
success = upload(self.binary_file.name, 'foo')
self.assertTrue(success)
self.assertIn(
call('Application uploaded successfully (as revision {})'.format(
revision)),
self.mock_logger.info.call_args_list)
self.assertIn(call('Please check out the application at: %s\n',
application_url),
self.mock_logger.info.call_args_list)
def test_get_json_data(self, gobase_get_full_response):
response = Response()
response._content = "not a json object"
gobase_get_full_response.return_value = response
with self.assertRaises(GoCdApiException):
self.gobase.get_json_data(self.gobase.url)
def make_response(self, status_code=200, reason='OK', data=None):
data = data or {}
response = Response()
response.status_code = status_code
response.reason = reason
response._content = json.dumps(data).encode('utf-8')
return response
def test_snap_already_downloaded(self):
snap_content = b'1234567890'
snap_sha512 = ('12b03226a6d8be9c6e8cd5e55dc6c7920caaa39df14aab92d5e'
'3ea9340d1c8a4d3d0b8e4314f1f6ef131ba4bf1ceb9186ab87c'
'801af0d5c95b1befb8cedae2b9')
with open('os.snap', 'wb') as f:
f.write(snap_content)
mock_details = self.mock_get.return_value
mock_details.ok = True
mock_details.content = json.dumps({
'download_url': 'http://localhost',
'download_sha512': snap_sha512,
}).encode('utf-8')
mock_snap = Response()
mock_snap.status_code = 200
mock_snap._content = snap_content
self.mock_get.side_effect = [mock_details, mock_snap]
download('os', 'os.snap', None, 'amd64')
self.mock_logger.info.assert_has_calls([
call("Getting details for 'os'"),
call("Already downloaded 'os'")])
self.assertTrue(os.path.exists('os.snap'))
def test_outside_app(self):
resp = Response()
resp.status_code = 200
resp._content = '{"ok": true}'
flexmock(urlfetch.S).should_receive('request').with_args(
method='POST',
url='http://services.dev.guokr.com/taskqueue.json',
files=None,
data={
'appname': 'test',
'method_': 'GET',
'url_': 'http://www.g.cn',
'countdown_': 0
}).and_return(resp).once()
taskqueue.add_url('http://www.g.cn') # success
flexmock(urlfetch.S).should_receive('request').and_return(resp)
self.assertRaises(RuntimeError, taskqueue.add_url, '/test') # fail
self.assertRaises(RuntimeError, taskqueue.add, '.test_view') # fail
with self.app.test_request_context('http://localhost/testxx'):
flexmock(urlfetch.S).should_receive('request').with_args(
method='POST',
url='http://services.dev.guokr.com/taskqueue.json',
files=None,
data={
'appname': 'test',
'method_': 'POST',
'url_': 'http://backends.dev.guokr.com/test.json',
'countdown_': 0
}).and_return(resp).twice()
taskqueue.add_url('/test.json', method_='POST') # success
taskqueue.add('.test_view', method='POST') # success
def send(self, request, stream=False, timeout=None, verify=True, cert=None,
proxies=None):
resp = Response()
resp.status_code = 200
ticket = re.findall(r"abematv-license://(.*)", request.url)[0]
resp._content = self._get_videokey_from_ticket(ticket)
return resp
def new_response(self, response):
"""Convert an tornado.HTTPResponse object to a requests.Response object"""
new = Response()
new._content = response.body
new.status_code = response.code
new.headers = dict(response.headers.get_all())
return new
def build_response(request,
status_code=200,
headers={},
content='(none)'):
"""
Build a :class:`requests.Response` object on the basis of the passed
parameters.
"""
response = Response()
response.status_code = status_code
response.reason = responses[status_code]
response.headers = CaseInsensitiveDict(headers)
# Pretend that we've already read from the socket
response._content = content
response.encoding = get_encoding_from_headers(response.headers)
response.url = request.url
response.raw = MockRawResponse()
# Give the Response some context.
response.request = request
response.connection = MockConnection()
return response
def test_upload_app_ignore_non_ok_responses(self):
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps(
{'completed': True, 'revision': 14}).encode('utf-8')
nok_response = Response()
nok_response.status_code = 503
self.mock_get.side_effect = [nok_response, nok_response, ok_response]
response = upload_app(self.package_name, self.data)
self.assertEqual(response, {
'success': True,
'errors': [],
'application_url': '',
'revision': 14,
})
self.assertEqual(self.mock_get.call_count, 3)
def test_request_failure_with_error_payload(self):
response = Response()
response.status_code = 400
response._content = bytes('{"errors":[{"message":"Bad request"}]}', "UTF-8")
with self.assertRaises(HTTPError) as cm:
_validate_cloudflare_response(response, _on_update_success)
self.assertEqual(str(cm.exception), "400 Client Error: None for url: None: Bad request")
async def new_response(self, response):
"""Convert an aiohttp.Response object to a requests.Response object"""
new = Response()
new._content = await response.read()
new.status_code = response.status
new.headers = response.headers
new.cookies = response.cookies
new.encoding = response.charset
return new
def _get_dummy_response(body, status_code=200) -> Response:
body_encoding = "utf-8"
body_string = body if isinstance(body, str) else json.dumps(body)
body_bytes = bytes(body_string, body_encoding)
response = Response()
response.status_code = status_code
response.encoding = body_encoding
response._content = body_bytes
return response
def test_request_failure_without_error_payload(self):
response = Response()
response.status_code = 400
response._content = bytes('{}', "UTF-8")
with self.assertRaises(ValueError) as cm:
_validate_cloudflare_response(response, _on_update_success)
self.assertEqual(str(cm.exception), "Cloudflare API response was malformed: b'{}'")
def test_execute(self):
client = ApiClient()
with patch('yandex_checkout.client.ApiClient.execute') as request_mock:
res = Response()
res.status_code = 200
res._content = b"{}"
request_mock.return_value = res
client.request(HttpVerb.POST, '/path', RequestObject({"param": "param"}), {'header': 'header'})
def response2(self):
resp = Response()
resp.status_code = 200
resp.url = 'https://www.youtube.com/watch?v=scbrjaqM3Oc'
resp.encoding = 'utf8'
resp.headers['content-type'] = 'text/html'
with open('tests/fixtures/article-2.html') as fd:
resp._content = fd.read()
return resp
def get_response(self, scheme='http:'):
resp = Response()
resp.url = scheme + self.response_url
resp.status_code = 200
resp.encoding = 'utf8'
resp.headers['content-type'] = 'text/html'
with open('tests/fixtures/article.html') as fd:
resp._content = fd.read()
return resp
def mocked_post(*args, **kwargs):
mocked_response = Response()
requested_url = args[1]
if "/server/request-token/" == urlparse(requested_url).path:
# token generated for private key settings.SSO_PRIVATE_KEY = 'priv1'
mocked_response._content = (
b'{"request_token": "XcHtuemqcjnIT6J2WHTFswLQP0W07nI96XfxqGkm6b1zFToF0YGEoIYu3'
b'7QOajkc"}.XTd9sA.quRsXFxqMk-ufwSc79q-_YLDNzg'
)
elif "/server/verify/" == urlparse(requested_url).path:
mocked_response._content = (
b'{"username": "******", "email": "*****@*****.**", "first_name": '
b'"Jan", "last_name": "Kowalski", "is_staff": false, "is_superuser": false, '
b'"is_active": true}.XTg4IQ._cANZR5jHvtwhNzcnNYDfE1nLHE'
)
mocked_response.status_code = 200
return mocked_response
def test_operation_failure_with_valid_payload(self):
response = Response()
response.status_code = 200
response._content = bytes('{"success":false,"errors":[{"message":"Bad request"}]}', "UTF-8")
with self.assertRaises(ValueError) as cm:
_validate_cloudflare_response(response, _on_update_success)
self.assertEqual(str(cm.exception), "Operation failed: Bad request")
def test_invalid_payload(self):
response = Response()
response.status_code = 200
response._content = bytes("abc", "UTF-8")
with self.assertRaises(ValueError) as cm:
_validate_cloudflare_response(response, _on_update_success)
self.assertEqual(str(cm.exception), "Cloudflare API response did not contain valid JSON: b'abc'")
def fake_request(*args, **kwargs):
# FIXME: Replace with responses
r = Response()
r.status_code = 200
try:
_token = kwargs['headers']['Authorization']
except KeyError:
r._content = b'{"shoe_size": 10}' # type: ignore
else:
_token = _token[7:]
if _token == 'abcdef':
r._content = b'{"shoe_size": 11}' # type: ignore
else:
r._content = b'{"shoe_size": 12}' # type: ignore
r.headers = {'content-type': 'application/json'}
return r
def __return_response(actual_endpoint, expected_endpoint, http_code,
json_result):
if actual_endpoint == expected_endpoint:
response = Response()
response.status_code = http_code
response._content = json_result.encode()
return response
raise Exception('Fail ! BAD endpoint.\nActual : %s\nExpected: %s' %
(actual_endpoint, expected_endpoint))
def test_update_funding_fails_on_rate_limit(self, get_markets_mock: AsyncMock):
resp = Response()
resp.status_code = 429
resp._content = b'{"errors": [{"msg": "Too many requests"}]}'
get_markets_mock.return_value = DydxApiError(resp)
self.async_run_with_timeout(self.exchange._update_funding_rates())
self.check_is_logged(log_level="NETWORK", message="Rate-limit error.")
def fake_request(*args, **kwargs):
# FIXME: Replace with responses
r = Response()
r.status_code = 200
try:
_token = kwargs["headers"]["Authorization"]
except KeyError:
r._content = b'{"shoe_size": 10}' # type: ignore
else:
_token = _token[7:]
if _token == "abcdef":
r._content = b'{"shoe_size": 11}' # type: ignore
else:
r._content = b'{"shoe_size": 12}' # type: ignore
r.headers = {"content-type": "application/json"}
return r
def test_update_funding_fails_on_other_dydx_api_error(self, get_markets_mock: AsyncMock):
resp = Response()
resp.status_code = 430
resp._content = b'{"errors": [{"msg": "Some other dydx API error."}]}'
get_markets_mock.return_value = DydxApiError(resp)
self.async_run_with_timeout(self.exchange._update_funding_rates())
self.check_is_logged(log_level="NETWORK", message="dYdX API error.")
def test_view(self, mock):
resp = Response()
resp.status_code = 200
resp._content = json.dumps([{
'reference': 1,
}])
mock.return_value = resp
self.should_redirect_to_login_when_anonymous()
self.is_callable(self.user)
def test_get_recursive(self, mock_requests_request):
result_one = Response()
result_one.status_code = 200
result_one._content = str.encode(
'{"data": '
'[{"type": "test", "id": "abc"}], '
'"meta": {"total": 2}, '
'"links": {"next": "https://api.exonet.nl/next_page"}'
"}")
result_two = Response()
result_two.status_code = 200
result_two._content = str.encode('{"data": '
'[{"type": "test", "id": "def"}], '
'"meta": {"total": 2}, '
'"links": {"next": null}'
"}")
request_result = [result_one, result_two]
mock_requests_request.side_effect = request_result
self.request_builder.get_recursive()
mock_requests_request.assert_any_call(
"GET",
"https://api.exonet.nl/things",
headers={
"Accept": "application/vnd.Exonet.v1+json",
"Content-Type": "application/json",
"Authorization": "Bearer None",
},
json=None,
params={},
)
mock_requests_request.assert_any_call(
"GET",
"https://api.exonet.nl/next_page",
headers={
"Accept": "application/vnd.Exonet.v1+json",
"Content-Type": "application/json",
"Authorization": "Bearer None",
},
json=None,
params=None,
)
def test_aggregated_list_rest(
transport: str = "rest",
request_type=compute.AggregatedListAcceleratorTypesRequest):
client = AcceleratorTypesClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
)
# Everything is optional in proto3 as far as the runtime is concerned,
# and we are mocking out the actual API, so just send an empty request.
request = request_type()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.AcceleratorTypeAggregatedList(
id="id_value",
items={
"key_value":
compute.AcceleratorTypesScopedList(accelerator_types=[
compute.AcceleratorType(
creation_timestamp="creation_timestamp_value")
])
},
kind="kind_value",
next_page_token="next_page_token_value",
self_link="self_link_value",
unreachables=["unreachables_value"],
warning=compute.Warning(code=compute.Warning.Code.CLEANUP_FAILED),
)
# Wrap the value into a proper Response obj
json_return_value = compute.AcceleratorTypeAggregatedList.to_json(
return_value)
response_value = Response()
response_value.status_code = 200
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.aggregated_list(request)
# Establish that the response is the type that we expect.
assert isinstance(response, pagers.AggregatedListPager)
assert response.id == "id_value"
assert response.items == {
"key_value":
compute.AcceleratorTypesScopedList(accelerator_types=[
compute.AcceleratorType(
creation_timestamp="creation_timestamp_value")
])
}
assert response.kind == "kind_value"
assert response.next_page_token == "next_page_token_value"
assert response.self_link == "self_link_value"
assert response.unreachables == ["unreachables_value"]
assert response.warning == compute.Warning(
code=compute.Warning.Code.CLEANUP_FAILED)
def side_effect(url, stream=False):
response = Response()
response.status_code = 200
response._content_consumed = True
if 'bulkdata' in url:
response._content = """
<CFRDOC>
<AMDDATE>Jan 1, 2001</AMDDATE>
<PARTS>Part 111 to 222</PARTS>
%s
%s
</CFRDOC>""" % (pt111, pt112)
elif url.endswith('part111.xml'):
response._content = pt111
elif url.endswith('part112.xml'):
response._content = pt112
else:
response.status_code = 404
return response
def test_send_message_json_OK(mock_send):
svc = OnapService()
mocked_response = Response()
mocked_response._content = b'{"yolo": "yala"}'
mocked_response.encoding = "UTF-8"
mocked_response.status_code = 200
mock_send.return_value = mocked_response
response = svc.send_message_json("GET", 'test get', 'http://my.url/')
mock_send.assert_called_once_with("GET", 'test get', 'http://my.url/')
assert response['yolo'] == 'yala'
def make_response(content: dict = None,
dumped_data: str = None,
status_code: int = 200,
reason: str = "OK") -> Response:
response_obj = Response()
response_obj.status_code = status_code
response_obj._content = dumped_data if dumped_data else dump_any_dict(
content).encode()
response_obj.reason = reason
return response_obj
def get(self, method, url, *a, **kw):
assert method == "GET"
assert url == collection_url
r = Response()
r.status_code = 200
assert responses
r._content = responses.pop().encode("utf-8")
r.headers["Content-Type"] = "text/calendar"
r.encoding = "ISO-8859-1"
return r
def test_send_message_json_bad_json_no_exception(mock_send):
svc = OnapService()
mocked_response = Response()
mocked_response._content = b'yolo'
mocked_response.encoding = "UTF-8"
mocked_response.status_code = 200
mock_send.return_value = mocked_response
response = svc.send_message_json("GET", 'test get', 'http://my.url/')
mock_send.assert_called_once_with("GET", 'test get', 'http://my.url/')
assert response == {}
def test_page_handler_is_called_for_json(self, *_):
"""Assert page handler is called when json without a task."""
response = Response()
response.status_code = 201
response._content = b'{"foo": "1234"}'
response.headers["Content-Type"] = "application/json"
with mock.patch.object(api, "page_handler",
lambda *_: "page_handler_called"):
self.assertEqual(api.smart_handler(self.client, response),
"page_handler_called")
def test_task_handler_is_called_for_tasks(self, *_):
"""Assert task handler is called when 202 with task is response."""
response = Response()
response.status_code = 202
response._content = b'{"task": "1234"}'
response.headers["Content-Type"] = "application/json"
with mock.patch.object(api, "task_handler",
lambda *_: "task_handler_called"):
self.assertEqual(api.smart_handler(self.client, response),
"task_handler_called")
def list(self, ctx):
response = Response()
response.status_code = 200
res = []
for __theme in available_themes:
t1 = {"theme": __theme}
res.append(t1)
t = {"list": res}
response._content = json.dumps(t).encode('utf-8')
return response
def ctms_error(self, status_code, detail, reason):
"""Return a CTMS error response"""
response = Response()
response.status_code = status_code
response._content = json.dumps({"detail": detail})
if reason:
response.reason = reason
error = HTTPError()
error.response = response
return error
def get(self, method, url, *a, **kw):
assert method == 'GET'
assert url == collection_url
r = Response()
r.status_code = 200
assert responses
r._content = responses.pop().encode('utf-8')
r.headers['Content-Type'] = 'text/icalendar'
r.encoding = 'ISO-8859-1'
return r
def mock_session_get(self, url: str) -> Response:
# pylint: disable=W0212(protected-access)
# pylint: disable=W0613(unused-argument)
print(f"Mocking get for URL: {url}")
response = Response()
response.status_code = 200
response.url = expected_url
response._content = expected_content
return response
def _mock_get(self, endpoint: str, *args, **kwargs) -> Response:
from tests.test_srvs import django_srv
response = Response()
data: Dict[str, Dict[str, str]] = handle_requests.get_data(django_srv.root)
response._content = json.dumps(data)
response.status_code = 200
return response