def test_unexpected_status_code(self):
"""
Test the `UnexpectedStatusCodeException` exception.
"""
# with .json() exception raised
response = Mock()
response.json = Mock()
response.json.side_effect = Exception("Test")
response.status_code = 1234
exception = UnexpectedStatusCodeException(message="Test message",
response=response)
self.assertEqual(exception.status_code, 1234)
self.assertIsNone(exception.json)
self.assertEqual(
str(exception),
"Test message! Unexpected status code: 1234, with response body: None"
)
# with .json() value
response = Mock()
response.json = Mock()
response.json.return_value = {"test": "OK!"}
response.status_code = 4321
exception = UnexpectedStatusCodeException(
message="Second test message", response=response)
self.assertEqual(exception.status_code, 4321)
self.assertEqual(exception.json, {"test": "OK!"})
self.assertEqual(
str(exception),
"Second test message! Unexpected status code: 4321, with response body: {'test': 'OK!'}"
)
def test_call_headers_dict(self):
app = Goblet(function_name="goblet_example")
mock = Mock()
@app.http(headers={"test": 1, "test2": 2})
def mock_function(request):
mock()
return True
mock_request = Mock()
mock_request.path = "/"
mock_request.headers = {"test": 1, "test2": 2}
mock_request.json = {}
mock_request2 = Mock()
mock_request2.path = "/"
mock_request2.headers = {"test": 1}
mock_request2.json = {}
mock_request3 = Mock()
mock_request3.path = "/"
mock_request3.headers = {"test": 3}
mock_request3.json = {}
app(mock_request, None)
app(mock_request2, None)
app(mock_request3, None)
assert mock.call_count == 1
def test_071__pem_cert_chain_generate(self, mock_get):
""" _pem_cert_chain_generate - request returns certificate three certs """
cert_dic = {
'issuer': 'issuer',
'certificateBase64': 'certificateBase641'
}
mockresponse1 = Mock()
mockresponse1.json = lambda: {'certificates': {'active': 'active'}}
mockresponse2 = Mock()
mockresponse2.json = lambda: {
'certificateBase64': 'certificateBase642',
'issuer': 'issuer'
}
mockresponse3 = Mock()
mockresponse3.json = lambda: {'certificates': {'active': 'active'}}
mockresponse4 = Mock()
mockresponse4.json = lambda: {
'certificateBase64': 'certificateBase643',
'issuer': 'issuer'
}
mockresponse5 = Mock()
mockresponse5.json = lambda: {'foo': 'bar'}
mock_get.side_effect = [
mockresponse1, mockresponse2, mockresponse3, mockresponse4,
mockresponse5
]
self.assertEqual(
'-----BEGIN CERTIFICATE-----\ncertificateBase641\n-----END CERTIFICATE-----\n-----BEGIN CERTIFICATE-----\ncertificateBase642\n-----END CERTIFICATE-----\n-----BEGIN CERTIFICATE-----\ncertificateBase643\n-----END CERTIFICATE-----\n',
self.cahandler._pem_cert_chain_generate(cert_dic))
def test_unsubscribe_lookup_error(self, mock_requests_post, mock_requests_get):
"""Newsletter unsubscribe should report lookup failure"""
# http://basket.readthedocs.io/newsletter_api.html#news-lookup-user
expected_get_params = {
'api_key': EXPECTED_BASKET_API_KEY,
'email': self.user.email
}
mock_get_response = Mock()
mock_get_json = Mock(return_value={
'status': 'error',
'desc': 'user not found'
})
mock_get_response.json = mock_get_json
mock_requests_get.return_value = mock_get_response
# http://basket.readthedocs.io/newsletter_api.html#news-unsubscribe
mock_post_response = Mock()
mock_post_json = Mock()
mock_post_response.json = mock_post_json
mock_requests_post.return_value = mock_post_response
profile = UserProfile.objects.get_profile(self.user)
result = profile.unsubscribe()
self.assertEqual('email not found in basket', result)
mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL,
params=expected_get_params)
mock_get_json.assert_called_with()
self.assertFalse(mock_requests_post.called)
self.assertFalse(mock_post_json.called)
def test_unsubscribe_request_exception(self, mock_requests_post, mock_requests_get):
"""Newsletter unsubscribe should gracefully handle request exceptions"""
expected_get_params = {
'api_key': EXPECTED_BASKET_API_KEY,
'email': self.user.email
}
mock_get_response = Mock()
mock_get_json = Mock(return_value={})
mock_get_response.json = mock_get_json
expected_result = Timeout()
def raise_request_exception(*args, **kwargs):
raise expected_result
mock_requests_get.side_effect = raise_request_exception
mock_requests_get.return_value = mock_get_response
mock_post_response = Mock()
mock_post_json = Mock()
mock_post_response.json = mock_post_json
mock_requests_post.return_value = mock_post_response
profile = UserProfile.objects.get_profile(self.user)
result = profile.unsubscribe()
self.assertEqual(expected_result, result)
mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL,
params=expected_get_params)
self.assertFalse(mock_get_json.called)
self.assertFalse(mock_requests_post.called)
self.assertFalse(mock_post_json.called)
def test_call_route(self):
app = Goblet(function_name="goblet_example")
mock = Mock()
mock_param = Mock()
app.route("/test")(mock_dummy_function(mock))
@app.route("/test/{param}", methods=["POST"])
def mock_function2(param):
mock_param(param)
return True
mock_event1 = Mock()
mock_event1.path = "/test"
mock_event1.method = "GET"
mock_event1.headers = {}
mock_event1.json = {}
app(mock_event1, None)
mock_event2 = Mock()
mock_event2.path = "/test/param"
mock_event2.method = "POST"
mock_event2.headers = {}
mock_event2.json = {}
app(mock_event2, None)
assert mock.call_count == 1
mock_param.assert_called_once_with("param")
def get(self, url: str, params=None):
mock = Mock()
if 'abci_query' in url:
def mock_json():
return {
'result': {
'response': {
'code': 0,
'value': {
'custody':
'391b31c15035cfd18782149267d39361c61a7672f90f6fcedac27500fba25d00'
}
}
}
}
mock.json = mock_json
elif 'broadcast_tx_sync' in url:
def mock_json():
return {
'result': {
'code': 0,
}
}
mock.json = mock_json
return mock
def login_with_mlc(
app,
name="user",
scope="profile%20team",
email="*****@*****.**",
oauth_id=1337,
team_name="TestTeam",
team_oauth_id=1234,
raise_for_error=True,
):
with app.test_client() as client, patch.object(
requests, "get") as fake_get_request, patch.object(
requests, "post") as fake_post_request:
client.get("/login")
with client.session_transaction() as sess:
nonce = sess["nonce"]
redirect_url = "{endpoint}?response_type=code&client_id={client_id}&scope={scope}&state={state}".format(
endpoint=app.config["OAUTH_AUTHORIZATION_ENDPOINT"],
client_id=app.config["OAUTH_CLIENT_ID"],
scope=scope,
state=nonce,
)
r = client.get("/oauth", follow_redirects=False)
assert r.location == redirect_url
fake_post_response = Mock()
fake_post_request.return_value = fake_post_response
fake_post_response.status_code = 200
fake_post_response.json = lambda: {
"access_token": "fake_mlc_access_token"
}
fake_get_response = Mock()
fake_get_request.return_value = fake_get_response
fake_get_response.status_code = 200
fake_get_response.json = lambda: {
"id": oauth_id,
"name": name,
"email": email,
"team": {
"id": team_oauth_id,
"name": team_name
},
}
client.get(
"/redirect?code={code}&state={state}".format(code="mlc_test_code",
state=nonce),
follow_redirects=False,
)
if raise_for_error:
with client.session_transaction() as sess:
assert sess["id"]
assert sess["nonce"]
assert sess["hash"]
return client
def test_get_and_update_iou():
request_args = dict(
url='url',
token_network_address=factories.UNIT_TOKEN_NETWORK_ADDRESS,
sender=factories.make_checksum_address(),
receiver=factories.make_checksum_address(),
)
# RequestExceptions should be reraised as ServiceRequestFailed
with pytest.raises(ServiceRequestFailed):
with patch.object(requests,
'get',
side_effect=requests.RequestException):
get_last_iou(**request_args)
# invalid JSON should raise a ServiceRequestFailed
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(side_effect=ValueError)
with pytest.raises(ServiceRequestFailed):
with patch.object(requests, 'get', return_value=response):
get_last_iou(**request_args)
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(return_value={'other_key': 'other_value'})
with patch.object(requests, 'get', return_value=response):
iou = get_last_iou(**request_args)
assert iou is None, 'get_pfs_iou should return None if pfs returns no iou.'
response = Mock()
response.configure_mock(status_code=200)
last_iou = make_iou(
config=dict(
pathfinding_eth_address=to_checksum_address(
factories.UNIT_TRANSFER_TARGET),
pathfinding_iou_timeout=500,
pathfinding_max_fee=100,
),
our_address=factories.UNIT_TRANSFER_INITIATOR,
privkey=PRIVKEY,
block_number=10,
)
response.json = Mock(return_value=dict(last_iou=last_iou))
with patch.object(requests, 'get', return_value=response):
iou = get_last_iou(**request_args)
assert iou == last_iou
new_iou_1 = update_iou(iou.copy(), PRIVKEY, added_amount=10)
assert new_iou_1['amount'] == last_iou['amount'] + 10
assert all(new_iou_1[k] == iou[k]
for k in ('expiration_block', 'sender', 'receiver'))
assert 'signature' in new_iou_1
new_iou_2 = update_iou(iou, PRIVKEY, expiration_block=45)
assert new_iou_2['expiration_block'] == 45
assert all(new_iou_2[k] == iou[k]
for k in ('amount', 'sender', 'receiver'))
assert 'signature' in new_iou_2
def test_two_new_decks_are_same(self):
response_mock = Mock()
response_mock.status_code = 200
response_mock.json.return_value = NEW_PARTIAL_DECK
response_mock2 = Mock()
response_mock2.status_code = 200
response_mock2.json.return_value = NEW_PARTIAL_DECK
# expected to be true
self.assertEqual(response_mock.json()['deck_id'],
response_mock2.json()['deck_id']) == True
def test_cors(self):
app = Goblet(function_name="goblet_cors")
app2 = Goblet(function_name="goblet_cors",
cors=CORSConfig(allow_origin="app-level"))
@app.route("/test", cors=True)
def mock_function():
return "200"
@app2.route("/test2")
def mock_function2():
return Response("200")
@app2.route("/override", cors=CORSConfig(allow_origin="override"))
def mock_function_override():
return Response("200")
@app.route("/test3", cors=CORSConfig(allow_origin="localhost"))
def mock_function3():
return jsonify("200")
mock_event1 = Mock()
mock_event1.path = "/test"
mock_event1.method = "GET"
mock_event1.headers = {}
mock_event1.json = {}
resp = app(mock_event1, None)
assert resp.headers["Access-Control-Allow-Origin"] == "*"
mock_event2 = Mock()
mock_event2.path = "/test2"
mock_event2.method = "GET"
mock_event2.headers = {}
mock_event2.json = {}
resp2 = app2(mock_event2, None)
assert resp2.headers["Access-Control-Allow-Origin"] == "app-level"
mock_event_override = Mock()
mock_event_override.path = "/override"
mock_event_override.method = "GET"
mock_event_override.headers = {}
mock_event_override.json = {}
resp2 = app2(mock_event_override, None)
assert resp2.headers["Access-Control-Allow-Origin"] == "override"
mock_event3 = Mock()
mock_event3.path = "/test3"
mock_event3.method = "GET"
mock_event3.headers = {}
mock_event3.json = {}
resp3 = app(mock_event3, None)
assert resp3[2]["Access-Control-Allow-Origin"] == "localhost"
def test_post_genre_serializer(self):
"""
Test correct format for post serializers
"""
data = {'name': 'rock', 'description': 'nice'}
request = Mock()
request.json = data
PostGenreSerializer(request=request)
data = {'description': 'nice'}
request.json = data
with pytest.raises(ValidationError) as excinfo:
PostGenreSerializer(request=request)
assert "'name' is a required property" in str(excinfo.value)
def test_069__pem_cert_chain_generate(self, mock_get):
""" _pem_cert_chain_generate - request returns certificate and active, 2nd request is bogus """
cert_dic = {
'issuer': 'issuer',
'certificateBase64': 'certificateBase641'
}
mockresponse1 = Mock()
mockresponse1.json = lambda: {'certificates': {'active': 'active'}}
mockresponse2 = Mock()
mockresponse2.json = lambda: {'foo': 'bar'}
mock_get.side_effect = [mockresponse1, mockresponse2]
self.assertEqual(
'-----BEGIN CERTIFICATE-----\ncertificateBase641\n-----END CERTIFICATE-----\n',
self.cahandler._pem_cert_chain_generate(cert_dic))
def test_072__pem_cert_chain_generate(self, mock_get):
""" _pem_cert_chain_generate - issuerCa in """
cert_dic = {
'issuerCa': 'issuerCa',
'certificateBase64': 'certificateBase641'
}
mockresponse1 = Mock()
mockresponse1.json = lambda: {'certificates': 'certificates'}
mockresponse2 = Mock()
mockresponse2.json = lambda: {'foo': 'bar'}
mock_get.side_effect = [mockresponse1, mockresponse2]
self.assertEqual(
'-----BEGIN CERTIFICATE-----\ncertificateBase641\n-----END CERTIFICATE-----\n',
self.cahandler._pem_cert_chain_generate(cert_dic))
def request(method: str, url: str, *args: Any, **kwargs: Any) -> Mock:
response = Mock()
response.status_code = 200
if "/idsrv" in url:
response.json = Mock(return_value={
"token_type": "Bearer",
"access_token": "SECRET",
"expires_in": expires_in.total_seconds(),
})
else:
response.json = Mock(return_value={})
return response
def test_update_check_ignores_downgrades(fake_post_request):
"""Update checks do nothing on old or same versions"""
app = create_ctfd()
with app.app_context():
app.config["UPDATE_CHECK"] = True
fake_response = Mock()
fake_post_request.return_value = fake_response
fake_response.json = lambda: {
u"resource": {
u"html_url":
u"https://github.com/CTFd/CTFd/releases/tag/0.0.1",
u"download_url":
u"https://api.github.com/repos/CTFd/CTFd/zipball/0.0.1",
u"published_at": u"Wed, 25 Oct 2017 19:39:42 -0000",
u"tag": u"0.0.1",
u"prerelease": False,
u"id": 6,
u"latest": True,
}
}
update_check()
assert get_config("version_latest") is None
fake_response = Mock()
fake_post_request.return_value = fake_response
fake_response.json = lambda: {
u"resource": {
u"html_url":
u"https://github.com/CTFd/CTFd/releases/tag/{}".format(
app.VERSION),
u"download_url":
u"https://api.github.com/repos/CTFd/CTFd/zipball/{}".format(
app.VERSION),
u"published_at":
u"Wed, 25 Oct 2017 19:39:42 -0000",
u"tag":
u"{}".format(app.VERSION),
u"prerelease":
False,
u"id":
6,
u"latest":
True,
}
}
update_check()
assert get_config("version_latest") is None
destroy_ctfd(app)
def happy_path_fixture(chain_state, token_network_state, our_address):
token_network_state, addresses, channel_states = create_square_network_topology(
token_network_state=token_network_state, our_address=our_address)
address1, address2, address3, address4 = addresses
chain_state.nodeaddresses_to_networkstates = {
address1: NODE_NETWORK_REACHABLE,
address2: NODE_NETWORK_REACHABLE,
address3: NODE_NETWORK_REACHABLE,
address4: NODE_NETWORK_REACHABLE,
}
json_data = {
"result": [{
"path": [
to_checksum_address(our_address),
to_checksum_address(address2),
to_checksum_address(address3),
to_checksum_address(address4),
],
"fees":
0,
}]
}
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(return_value=json_data)
return addresses, chain_state, channel_states, response, token_network_state
def test_get_pfs_info_success():
json_data = {
"price_info": 0,
"network_info": {
"chain_id": 1,
"registry_address": "0xB9633dd9a9a71F22C933bF121d7a22008f66B908",
},
"message": "This is your favorite pathfinding service",
"operator": "John Doe",
"version": "0.0.1",
}
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(return_value=json_data)
with patched_get_for_succesful_pfs_info():
pathfinding_service_info = get_pfs_info("url")
req_registry_address = "0xB9633dd9a9a71F22C933bF121d7a22008f66B908"
assert pathfinding_service_info["price_info"] == 0
assert pathfinding_service_info["network_info"]["chain_id"] == 1
assert pathfinding_service_info["network_info"][
"registry_address"] == req_registry_address
assert pathfinding_service_info[
"message"] == "This is your favorite pathfinding service"
assert pathfinding_service_info["operator"] == "John Doe"
assert pathfinding_service_info["version"] == "0.0.1"
def fake_get_delta(delta_token, item_id, drive_id):
"""To mock the get_delta iterator and get desired returns."""
item_list = []
if item_id == '0':
root = dict()
root['id'] = item_id
item_list.append(root)
file_b = dict()
file_b['name'] = 'file_b'
file_b['id'] = '2'
file_b['parentReference'] = {'id': '0'}
file_b['deleted'] = {}
file_b['cTag'] = 'b_ctag'
file_b['lastModifiedDateTime'] = '4:30:21.447'
item_list.append(file_b)
else:
raise HTTPError(
'Recreating the error when accesing no longer existing file.')
api = Mock()
response = Mock()
response.json = Mock(return_value={
'value': item_list,
'@delta.token': 'delta'
})
api.get = Mock(return_value=response)
iterator = onedrive.OneDriveIterator(api, 'fake')
iterator.last_response = mock.Mock(return_value={'@delta.token': ''})
return iterator
def test_onedrive_iterator_with_pagination():
"""Iterator must return all values until is '@odata.nextLink' not returned.
"""
def fake_responses():
"""Fake json responses which contains '@odata.nextLink' for first but call only.
"""
if fake_responses.called == 0:
res = {'value': [0, 1, 2, 3], '@odata.nextLink': 'blub'}
else:
res = {'value': [4, 5, 6, 7]}
fake_responses.called += 1
return res
fake_responses.called = 0
api = Mock()
response = Mock()
response.json = Mock(side_effect=fake_responses)
api.get = Mock(return_value=response)
iterator = onedrive.OneDriveIterator(api, 'xxx')
assert list(iterator) == list(range(8))
api.get.assert_any_call(endpoint='xxx', params={})
api.get.assert_any_call(url='blub')
assert api.get.call_count == 2
def test_process_callback(self, post_mock):
mock_token = "AQUpBbh2h2cBV79XaDuI7BX7adhiCBsGZbJAk9U-NiVajfoXyY5Vg5evEByHd5XrTKXB87YjNZVfXqVJ8O0zD8kHJ_mTglttKNt4FmVxqo8yw_6ZSSn9kW8m2-rM4PAM7saq53TUc0EIFgmRo1l2DEhzSwXPcasLXTk2pCrW1u4cWoPxBo4BKaCL-iG4eIqZSMvgjjDJF-1wVttpFtU8NdrKMzSBcxJZ_jZMy98r7_WMw-Gusaz12ocjfJyhOHID5PVHJW0w9Wi40WJsXZ1iHw_Tlk2olrvew5Q6R7HFjW53yFLBvkafMRdpV4mI6n-92tq_hCHzQCgHUAqfZXnN-GG7Wz5hUw"
mock_expires_in = 5183999
json_mock = Mock()
json_mock.return_value = {
"access_token": mock_token,
"expires_in": mock_expires_in
}
response_mock = Mock()
response_mock.json = json_mock
response_mock.status_code = 200
response_mock.content = b'{"access_token":"AQUpBbh2h2cBV79XaDuI7BX7adhiCBsGZbJAk9U-NiVajfoXyY5Vg5evEByHd5XrTKXB87YjNZVfXqVJ8O0zD8kHJ_mTglttKNt4FmVxqo8yw_6ZSSn9kW8m2-rM4PAM7saq53TUc0EIFgmRo1l2DEhzSwXPcasLXTk2pCrW1u4cWoPxBo4BKaCL-iG4eIqZSMvgjjDJF-1wVttpFtU8NdrKMzSBcxJZ_jZMy98r7_WMw-Gusaz12ocjfJyhOHID5PVHJW0w9Wi40WJsXZ1iHw_Tlk2olrvew5Q6R7HFjW53yFLBvkafMRdpV4mI6n-92tq_hCHzQCgHUAqfZXnN-GG7Wz5hUw","expires_in":5183999}'
post_mock.return_value = response_mock
linkedin_received_request = {
'code': "L3g7vIst8EW3t9PdQN6HwxS2X9fZyaUKCJQJ8hzdRtDBn6",
'state': self.state
}
token, expires_in = self.authorization.process_callback(
linkedin_received_request)
self.assertTrue(token, mock_token)
self.assertTrue(expires_in, mock_expires_in)
def test_checks_update_endpoint(self, json_response_mock):
self.scheduler.scheduler.start()
check = self.check
async def _json():
return check
request = Mock()
request.json = _json
response = self.loop.run_until_complete(
self.scheduler.update(request)
)
self.assertEqual(list(response), [])
json_response_mock.assert_called_with(
data={'status': 'scheduled'}, status=202
)
# test if already scheduled check will be removed
check['triggers'] = []
response = self.loop.run_until_complete(
self.scheduler.update(request)
)
self.assertEqual(list(response), [])
json_response_mock.assert_called_with(
data={'status': 'deleted'}, status=202
)
def get(path, headers=None, flg=None):
value = path.partition('?')[2]
result_state_values = {
'run_id=1': 'SUCCESS',
'run_id=2': 'FAILED',
'run_id=3': 'TIMEDOUT',
'run_id=4': None,
'run_id=5': 'CANCELED',
'run_id=6': 'FAILED'
}
life_cycle_state_values = {
'run_id=1': 'TERMINATED',
'run_id=2': 'TERMINATED',
'run_id=3': 'TERMINATED',
'run_id=4': 'SKIPPED',
'run_id=5': 'TERMINATED',
'run_id=6': 'INTERNAL_ERROR'
}
mock_resp = Mock()
mock_resp.json = Mock(
return_value={'job_id': 1000,
'run_id': 1000,
'state': {'life_cycle_state': life_cycle_state_values.get(value),
'result_state': result_state_values.get(value),
'state_message': ''},
'task': {'notebook_task': {'notebook_path': 'path/to/notebook/fail'}},
'run_page_url': 'https://westeurope.azuredatabricks.net/12121212#job/999/run/1'}
)
return mock_resp
def test_routing_mocked_pfs_invalid_json_structure(chain_state,
token_network_state,
our_address):
token_network_state, addresses, channel_states = create_square_network_topology(
token_network_state=token_network_state, our_address=our_address)
address1, address2, address3, address4 = addresses
channel_state1, channel_state2 = channel_states
# test routing with all nodes available
chain_state.nodeaddresses_to_networkstates = {
address1: NODE_NETWORK_REACHABLE,
address2: NODE_NETWORK_REACHABLE,
address3: NODE_NETWORK_REACHABLE,
}
response = Mock()
response.configure_mock(status_code=400)
response.json = Mock(return_value={})
with patch.object(requests, "post", return_value=response):
routes = get_best_routes_with_iou_request_mocked(
chain_state=chain_state,
token_network_state=token_network_state,
from_address=our_address,
to_address=address4,
amount=50,
)
# PFS doesn't work, so internal routing is used, so two possible routes are returned,
# whereas the path via address1 is shorter (
# even if the route is not possible from a global perspective)
# in case the mocked pfs response were used, we would not see address1 on the route
assert routes[0].node_address == address1
assert routes[0].channel_identifier == channel_state1.identifier
assert routes[1].node_address == address2
assert routes[1].channel_identifier == channel_state2.identifier
def test_xy_to_pir_API_single(self, image_id, x, y, mocker):
"""Test that xy to pir API works."""
# patching
fake_response = Mock(spec=requests.Request)
fake_response.status_code = 200
rv = {
"success": True,
"id": 0,
"start_row": 0,
"num_rows": 0,
"total_rows": 0,
"msg": {
"image_to_reference": {
"x": -983.5501122512056,
"y": 335.1538167934086,
"z": 4117.19706627407,
}
},
}
fake_response.json = Mock(return_value=rv)
mocker.patch("requests.get", return_value=fake_response)
p, i, r = xy_to_pir_API_single(x, y, image_id=image_id)
# Mock calls
assert (
fake_response.json.call_count == 1
) # assert_called not available in python 3.5 :(
assert np.isfinite(p)
assert np.isfinite(i)
assert np.isfinite(r)
def test_update_check_identifies_update(fake_get_request):
"""Update checks properly identify new versions"""
app = create_ctfd()
with app.app_context():
app.config["UPDATE_CHECK"] = True
fake_response = Mock()
fake_get_request.return_value = fake_response
fake_response.json = lambda: {
"resource": {
"download_url":
"https://api.github.com/repos/CTFd/CTFd/zipball/9.9.9",
"html_url": "https://github.com/CTFd/CTFd/releases/tag/9.9.9",
"id": 12,
"latest": True,
"next": 1542212248,
"prerelease": False,
"published_at": "Wed, 25 Oct 2017 19:39:42 -0000",
"tag": "9.9.9",
}
}
update_check()
assert (get_config("version_latest") ==
"https://github.com/CTFd/CTFd/releases/tag/9.9.9")
assert get_config("next_update_check") == 1542212248
destroy_ctfd(app)
def test_graphjinj():
""" Tests whether graphjinj works correctly """
session = requests.Session()
mock_response = Mock()
mock_response.json = lambda: {
"data": {
"allTasks": {
"edges": [
{
"node": {
"name": "task1"
}
},
{
"node": {
"name": "task2"
}
}
]
}
}
}
session.post = Mock(return_value=mock_response)
result = graphjinj.run(
"endpoint",
read_text("test.examples", "getTasks.gjinj"),
session=session
)
assert "task1" in result.display
assert "task2" in result.display
def _assert_is_vouched_on_mozillians(self, expected_vouched, email,
mock_api_data, mock_requests_get):
expected_api_url = '%(base_url)s/users/?api-key=%(api_key)s&email=%(email)s' % dict(
base_url='https://example.com',
api_key='8675309',
email=email
)
mock_json = Mock(return_value={
'count': 1,
'next': None,
'previous': None,
'results': [
{
'_url': 'https://mozillians.org/api/v2/users/12345/',
'is_vouched': expected_vouched,
'username': '******'
}
]
})
mock_response = Mock()
mock_response.json = mock_json
mock_requests_get.return_value = mock_response
result_vouched = is_vouched_on_mozillians_org(User(email=email))
self.assertEqual(expected_vouched, result_vouched)
mock_json.assert_called_with()
mock_requests_get.assert_called_with(expected_api_url)
def test_assert_response_ok_fails_with_reason(self):
response = Mock()
response.ok = False
response.json = MagicMock(
return_value={'message': 'this is my message'})
with assert_raises_regex(ZnailError, '.*this is my message.*'):
ZnailComponent('1.2.3.4')._assert_response_ok(response)
def test_superadmin_callback(
client: FlaskClient,
org_id: str, # pylint: disable=unused-argument
):
with patch.object(auth0_sa, "authorize_access_token", return_value=None):
mock_response = Mock()
mock_response.json = MagicMock(return_value={"email": SA_EMAIL})
with patch.object(auth0_sa, "get", return_value=mock_response):
rv = client.get("/auth/superadmin/callback?code=foobar")
assert rv.status_code == 302
assert urlparse(rv.location).path == "/superadmin/"
with client.session_transaction() as session: # type: ignore
assert session["_superadmin"] is True
assert_is_date(session["_created_at"])
assert datetime.now(timezone.utc) - datetime.fromisoformat(
session["_created_at"]) < timedelta(seconds=1)
assert_is_date(session["_last_request_at"])
assert datetime.now(timezone.utc) - datetime.fromisoformat(
session["_last_request_at"]) < timedelta(seconds=1)
assert list(session.keys()) == [
"_created_at",
"_last_request_at",
"_superadmin",
]
assert auth0_sa.authorize_access_token.called
assert auth0_sa.get.called
def setUpClass(cls):
""" prepare for testing """
org = TEST_PAYLOAD[0][0]
repos = TEST_PAYLOAD[0][1]
org_mock = Mock()
org_mock.json = Mock(return_value=org)
cls.org_mock = org_mock
repos_mock = Mock()
repos_mock.json = Mock(return_value=repos)
cls.repos_mock = repos_mock
cls.get_patcher = patch('requests.get')
cls.get = cls.get_patcher.start()
options = {cls.org_payload["repos_url"]: repos_mock}
cls.get.side_effect = lambda y: options.get(y, org_mock)
def test_get_pfs_info_success():
json_data = {
'price_info': 0,
'network_info': {
'chain_id': 1,
'registry_address': "0xB9633dd9a9a71F22C933bF121d7a22008f66B908",
},
'message': "This is your favorite pathfinding service",
'operator': "John Doe",
'version': "0.0.1",
}
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(return_value=json_data)
with patch.object(requests, 'get', return_value=response):
pathfinding_service_info = get_pfs_info("url")
req_registry_address = '0xB9633dd9a9a71F22C933bF121d7a22008f66B908'
assert pathfinding_service_info['price_info'] == 0
assert pathfinding_service_info['network_info']['chain_id'] == 1
assert pathfinding_service_info['network_info'][
'registry_address'] == req_registry_address
assert pathfinding_service_info[
'message'] == 'This is your favorite pathfinding service'
assert pathfinding_service_info['operator'] == 'John Doe'
assert pathfinding_service_info['version'] == '0.0.1'
def test_handle_stream_output_stream(self, args: Mock,
mock_output_stream: Mock):
"""
Test that the formatter does define the correct variables
"""
args.json = False
args.subprocess_cmdline = False
args.stream_url = False
args.output = False
args.stdout = False
args.url = "URL"
args.player_passthrough = []
args.player_external_http = False
args.player_continuous_http = False
mock_output_stream.return_value = True
plugin = _TestPlugin("")
plugin.author = "AUTHOR"
plugin.category = "CATEGORY"
plugin.title = "TITLE"
stream = Stream(session=Mock())
streams = {"best": stream}
handle_stream(plugin, streams, "best")
self.assertEqual(mock_output_stream.call_count, 1)
paramStream, paramFormatter = mock_output_stream.call_args[0]
self.assertIs(paramStream, stream)
self.assertIsInstance(paramFormatter, Formatter)
self.assertEqual(
paramFormatter.title(
"{url} - {author} - {category}/{game} - {title}"),
"URL - AUTHOR - CATEGORY/CATEGORY - TITLE")
def test_provider_chain_when_first_and_second_provider_fails(mock_fail_response):
# GIVEN
provider_it = iter(ShortyService.provider_map.values())
tinyurl_provider, bitly_provider, bitly_clone_provider = next(provider_it), next(provider_it), next(provider_it)
valid_url = 'https://example.com'
# Mock TinyUrlProvider's Response, and assign it to its post_data method
tinyurl_provider.post_data = Mock(return_value = mock_fail_response)
# Mock BitlyProvider's Response, and assign it to its post_data method
bitly_provider.post_data = Mock(return_value = mock_fail_response)
# Mock BitlyCloneProvider's Response, and assign it to its post_data method
mock_bitly_clone_post_resp = Mock()
mock_bitly_clone_post_resp.status_code = 200
mock_bitly_clone_post_resp.json = Mock(return_value = {'link': 'https://bit.ly/example'})
bitly_clone_provider.post_data = Mock(return_value = mock_bitly_clone_post_resp)
# WHEN
ShortyService().get_provider_chain().get_shortlink(valid_url)
# THEN
tinyurl_provider.post_data.assert_called_once()
bitly_provider.post_data.assert_called_once()
bitly_clone_provider.post_data.assert_called_once()
def test_resp_on_failure(self):
blk = RESTPolling()
blk._retry = Mock()
r = Mock()
r.json = Exception()
self.assertFalse(blk._retry.called)
blk._on_failure(r, paging=False, url='the_url')
self.assertTrue(blk._retry.called)
def test_routing_mocked_pfs_bad_http_code(
chain_state,
payment_network_state,
token_network_state,
our_address,
):
token_network_state, addresses, channel_states = create_square_network_topology(
payment_network_state=payment_network_state,
token_network_state=token_network_state,
our_address=our_address,
)
address1, address2, address3 = addresses
channel_state1, channel_state2 = channel_states
# test routing with all nodes available
chain_state.nodeaddresses_to_networkstates = {
address1: NODE_NETWORK_REACHABLE,
address2: NODE_NETWORK_REACHABLE,
address3: NODE_NETWORK_REACHABLE,
}
# channel 1 and 2 are flipped here, to see when the PFS gets called
json_data = {
'result': [
{
'path': [to_checksum_address(our_address), to_checksum_address(address2)],
'fees': 0,
},
{
'path': [to_checksum_address(our_address), to_checksum_address(address1)],
'fees': 0,
},
],
}
response = Mock()
response.configure_mock(status_code=400)
response.json = Mock(return_value=json_data)
with patch.object(requests, 'get', return_value=response):
routes = get_best_routes(
chain_state=chain_state,
token_network_id=token_network_state.address,
from_address=our_address,
to_address=address1,
amount=50,
previous_address=None,
config={
'services': {
'pathfinding_service_address': 'my-pfs',
'pathfinding_max_paths': 3,
},
},
)
assert routes[0].node_address == address1
assert routes[0].channel_identifier == channel_state1.identifier
assert routes[1].node_address == address2
assert routes[1].channel_identifier == channel_state2.identifier
def test_get_next_number_bad_response(self):
"""Verify the client can handle bad responses for the next number."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json = Mock(return_value={})
mock_post = Mock(return_value=mock_response)
# Act and assert
with patch('requests.post', mock_post):
self.assertRaises(DoorstopError, client.get_next_number, 'PREFIX')
def setUp(self):
# Mockando Objetos
response_mock = Mock()
def json():
return {'avatar_url': 'https://avatars.githubusercontent.com/u/3457115?v=3'}
response_mock.json = json
self.response_mock = response_mock
def test_generate_mailgun_response_json(self):
"""
Tests that generate_mailgun_response_json() returns response.json()
"""
response = Mock(
spec=Response,
status_code=status.HTTP_200_OK,
json=mocked_json()
)
assert generate_mailgun_response_json(response) == response.json()
def test_serializer_to_model(self):
request = Mock()
user_dict = {
'username': '******', 'password': '******',
'email': '*****@*****.**'}
request.json = user_dict
user_serializer = PostUserSerializer(request=request)
user_model = User(serializer=user_serializer)
assert user_dict['username'] == user_model.username
assert user_model.email == user_dict['email']
def test_get_next_number(self):
"""Verify the client can get the next number for a document."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json = Mock(return_value={'next': 42})
mock_post = Mock(return_value=mock_response)
# Act
with patch('requests.post', mock_post):
number = client.get_next_number('PREFIX')
# Assert
url = 'http://1.2.3.4:8080/documents/PREFIX/numbers'
headers = {'content-type': 'application/json'}
mock_post.assert_called_once_with(url, headers=headers)
self.assertEqual(42, number)
def test_unsubscribe(self, mock_requests_post, mock_requests_get):
"""Newsletter unsubscribe should call Basket API as expected"""
# http://basket.readthedocs.io/newsletter_api.html#news-lookup-user
expected_get_params = {
'api_key': EXPECTED_BASKET_API_KEY,
'email': self.user.email
}
expected_user_token = '8675309'
mock_get_response = Mock()
mock_get_json = Mock(return_value={
'token': expected_user_token
})
mock_get_response.json = mock_get_json
mock_requests_get.return_value = mock_get_response
# http://basket.readthedocs.io/newsletter_api.html#news-unsubscribe
expected_post_data = {
'newsletters': 'test-pilot',
'email': self.user.email
}
mock_post_response = Mock()
mock_post_json = Mock(return_value={'status': 'ok'})
mock_post_response.json = mock_post_json
mock_requests_post.return_value = mock_post_response
profile = UserProfile.objects.get_profile(self.user)
profile.unsubscribe()
mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL,
params=expected_get_params)
mock_get_json.assert_called_with()
expected_url = '%s%s/' % (EXPECTED_BASKET_UNSUBSCRIBE_URL,
expected_user_token)
mock_requests_post.assert_called_with(expected_url,
data=expected_post_data)
mock_post_json.assert_called_with()
def should_get_download_info():
revision = {'type': 'Revision',
'attributes': {'url': sentinel.url}}
s = Mock(spec=session.Session)
s.session = Mock()
response = Mock()
response.json = Mock(return_value=sentinel.result)
s.session.get = Mock(return_value=response)
s.token = sentinel.token
result = download.revision_download_info(s, revision)
assert_equal(result, sentinel.result)
s.session.get.assert_called_with(sentinel.url,
headers={'accept': 'application/json'},
params={'token': sentinel.token})
def test_routing_mocked_pfs_invalid_json_structure(
chain_state,
payment_network_state,
token_network_state,
our_address,
):
token_network_state, addresses, channel_states = create_square_network_topology(
payment_network_state=payment_network_state,
token_network_state=token_network_state,
our_address=our_address,
)
address1, address2, address3 = addresses
channel_state1, channel_state2 = channel_states
# test routing with all nodes available
chain_state.nodeaddresses_to_networkstates = {
address1: NODE_NETWORK_REACHABLE,
address2: NODE_NETWORK_REACHABLE,
address3: NODE_NETWORK_REACHABLE,
}
response = Mock()
response.configure_mock(status_code=400)
response.json = Mock(return_value={})
with patch.object(requests, 'get', return_value=response):
routes = get_best_routes(
chain_state=chain_state,
token_network_id=token_network_state.address,
from_address=our_address,
to_address=address1,
amount=50,
previous_address=None,
config={
'services': {
'pathfinding_service_address': 'my-pfs',
'pathfinding_max_paths': 3,
},
},
)
assert routes[0].node_address == address1
assert routes[0].channel_identifier == channel_state1.identifier
assert routes[1].node_address == address2
assert routes[1].channel_identifier == channel_state2.identifier
len(self.data.domain.attributes),
1)
self.assertEqual(corp.X.shape[1] - self.data.X.shape[1], 1)
self.assertEqual(np.sum(corp.X[:, -1]), 0)
@patch(CHECK_ALIVE, Mock(return_value=False))
def test_transform_probabilities(self):
text_var = self.data.domain.metas[1]
corp = self.profiler.transform(self.data, text_var,
MODELS[0], 'Classes')
self.assertIs(corp, self.data)
response_mock = Mock()
response_mock.status_code = 200
response_mock.json = lambda: {}
class TestErrorsRaising(unittest.TestCase):
@patch(SERVER_CALL, MockServerCall())
@patch(CHECK_ALIVE, Mock(return_value=True))
def setUp(self):
self.profiler = TweetProfiler()
@patch('requests.get', Mock(side_effect=requests.exceptions.ConnectionError))
def test_get_server_address_connection_error(self):
address = self.profiler.get_server_address()
self.assertIsNone(address)
@patch(CHECK_ALIVE, Mock(return_value=False))
def test_get_server_address_server_down(self):
def mock_response(
status=200,
content="CONTENT",
json_data=None,
raise_for_status=None,
url=None):
"""
since we typically test a bunch of different
requests calls for a service, we are going to do
a lot of mock responses, so its usually a good idea
to have a helper function that builds these things
"""
mock_resp = Mock()
# mock raise_for_status call w/optional error
mock_resp.raise_for_status = Mock()
if raise_for_status:
mock_resp.raise_for_status.side_effect = raise_for_status
# set status code and content
mock_resp.status_code = status
mock_resp.content = content
mock_resp.url = url
# add json data if provided
if json_data:
mock_resp.json = Mock(
return_value=json_data
)
return mock_resp
