def _location_field(self, *args, **kwargs):
name = kwargs.get('name')
if name is LOCATION_TYPE_FIELD_NAME:
location_field = Mock(spec=HierarchyField)
location_field.code = 'l'
return location_field
geo_code_field = Mock(spec=GeoCodeField)
geo_code_field.code = 'g'
return geo_code_field
def test_handle_produce_response_on_nonretriable(self, fake_decode,
fake_retry):
m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
response = Mock()
response.code = 500
response.error = False
response.request = Mock()
response.request._batch = [m1, m2]
response.request._id = 1
body = {
'offsets': [{}, {}],
'value_schema_id': 1,
'key_schema_id': 2,
'error_code': 50101,
'message': 'Nonretriable'
}
fake_decode.return_value = body
self.producer._handle_produce_response('test_driver', response)
calls = [
call('test_driver', m1, 'nonretriable'),
call('test_driver', m2, 'nonretriable')
]
self.client.mock_for('drop_message').assert_has_calls(calls)
def test_post_with_bad_data(service_client, get_repositories, get_repository):
get_repositories.return_value = future_repositories
get_repository.return_value = future_repository
mock_response = Mock()
mock_response.body = '{"errors": [{"source_id_type": "", "message": "not supported asset id type"}]}'
mock_response.code = 400
exc = httpclient.HTTPError(400, response=mock_response)
service_client.return_value = make_future(MagicMock())
client = yield service_client()
endpoint = client.repository.repositories[''].search.offers
endpoint.post.side_effect = exc
handler = _create_offers_handler()
# MUT
handler.request.body = ('[{"source_id":' +
'"https://openpermissions.org/s0/hub1/asset/exampleco/ExampleCoPictureID/1",' +
'"source_id_type":""}]')
with pytest.raises(HTTPError) as excinfo:
handler.post().result()
assert excinfo.value.status_code == mock_response.code
assert excinfo.value.errors == json.loads(mock_response.body)
def test_rpc_request_404(self):
response = Mock()
response.code = 404
response.phrase = "Not found."
response.body = escape.json_encode({"result": True})
cyclone.httpclient.fetch.return_value = succeed(response)
return self.assertFailure(self.client.foo(), HTTPError)
def test_handle_error_signal(self):
if not signals_available:
# This test requires the blinker lib to run.
print("Can't test signals without signal support")
return
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 400
exception.data = {'foo': 'bar'}
recorded = []
def record(sender, exception):
recorded.append(exception)
got_request_exception.connect(record, app)
try:
with app.test_request_context("/foo"):
api.handle_error(exception)
self.assertEquals(len(recorded), 1)
self.assertTrue(exception is recorded[0])
finally:
got_request_exception.disconnect(record, app)
def test_should_return_expected_success_response_for_registration(self):
self.form_submission_mock.is_registration = True
response = Response([{NAME_FIELD: "Mr. X"}], None, self.form_submission_mock.saved,
self.form_submission_mock.errors,
self.form_submission_mock.data_record_id,
self.form_submission_mock.short_code, self.form_submission_mock.cleaned_data,
self.form_submission_mock.is_registration,
['clinic'],
self.form_submission_mock.form_model.form_code)
dbm_mock = Mock()
form_model_mock = Mock(spec=EntityFormModel)
form_model_mock.stringify.return_value = {'name': 'Clinic X', 'q2':'cli001'}
short_code_field = Mock()
short_code_field.code = 'q2'
form_model_mock.entity_questions = [short_code_field]
form_model_mock.get_entity_name_question_code.return_value = 'name'
form_model_mock.entity_type = ["clinic"]
with patch("datawinners.messageprovider.message_handler.get_form_model_by_code") as get_form_model_mock:
with patch("datawinners.messageprovider.customized_message.account_wide_customized_message_details") as account_message:
get_form_model_mock.return_value = form_model_mock
account_message.return_value = [{"code":"reply_success_identification_number_registration",
"message":"Thanks {Name of Data Sender}.registered {Identification Number Type} "
"{Name of Identification Number} {Submitted Identification Number}",
"title": "Succesful register"}]
response_text = SMSResponse(response, None).text(dbm_mock)
self.assertEqual("Thanks Mr..registered clinic Clinic X cli001", response_text)
def test_handle_smart_errors(self):
app = Flask(__name__)
api = flask_restful.Api(app)
view = flask_restful.Resource
exception = Mock()
exception.code = 404
exception.data = {"status": 404, "message": "Not Found"}
api.add_resource(view, '/foo', endpoint='bor')
api.add_resource(view, '/fee', endpoint='bir')
api.add_resource(view, '/fii', endpoint='ber')
with app.test_request_context("/faaaaa"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 404)
self.assertEquals(resp.data, dumps({
"status": 404, "message": "Not Found",
}))
with app.test_request_context("/fOo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 404)
self.assertEquals(resp.data, dumps({
"status": 404, "message": "Not Found. You have requested this URI [/fOo] but did you mean /foo ?",
}))
with app.test_request_context("/fOo"):
del exception.data["message"]
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 404)
self.assertEquals(resp.data, dumps({
"status": 404, "message": "You have requested this URI [/fOo] but did you mean /foo ?",
}))
def test_rpc_request(self):
response = Mock()
response.code = 200
response.body = escape.json_encode({"result": True})
cyclone.httpclient.fetch.return_value = succeed(response)
result = yield self.client.foo()
self.assertTrue(result)
def test_handle_smart_errors(self):
app = Flask(__name__)
api = flask_restful.Api(app)
view = flask_restful.Resource
exception = Mock()
exception.code = 404
exception.data = {"status": 404, "message": "Not Found"}
api.add_resource(view, '/foo', endpoint='bor')
api.add_resource(view, '/fee', endpoint='bir')
api.add_resource(view, '/fii', endpoint='ber')
with app.test_request_context("/faaaaa"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 404)
self.assertEquals(resp.data, dumps({
"status": 404, "message": "Not Found",
}))
with app.test_request_context("/fOo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 404)
self.assertEquals(resp.data, dumps({
"status": 404, "message": "Not Found. You have requested this URI [/fOo] but did you mean /foo ?",
}))
with app.test_request_context("/fOo"):
del exception.data["message"]
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 404)
self.assertEquals(resp.data, dumps({
"status": 404, "message": "You have requested this URI [/fOo] but did you mean /foo ?",
}))
def test_onionoo_success(self):
agent = Mock()
resp = Mock()
resp.code = 200
def feed_response(protocol):
config = {
"relays": [
{
"fingerprint":
"00786E43CCC5409753F25E36031C5CEA6EA43702",
},
]
}
protocol.dataReceived(json.dumps(config).encode())
protocol.connectionLost(Failure(ResponseDone()))
resp.deliverBody = Mock(side_effect=feed_response)
agent.request = Mock(return_value=defer.succeed(resp))
data = yield self.router.get_onionoo_details(agent)
self.assertTrue('fingerprint' in data)
self.assertTrue(
data['fingerprint'] == "00786E43CCC5409753F25E36031C5CEA6EA43702")
def test_login_success(self, _mock):
mock_response = Mock()
mock_response.return_value = Future()
mock_response.code = 302
mock_response.headers.get_list.side_effect = lambda key: \
{
'Location': ['/Main/Index/d9359cb0-f9a7-42c4-89d6-c2c05f5875dc'],
'Set-Cookie': ['ASP.NET_SessionId=fwtqedargnx2ogfru0tsj544'],
}.get(key)
future = Future()
future.set_result(mock_response)
_mock.return_value = future
data = self._post({
'username': '******',
'password': '******'
})
self.assert_response_success(data)
user = data.get('user')
self.assertTrue(user)
self.assertIsNotNone(user['name'])
self.assertEqual(user['username'], '20140000')
def test_post_with_bad_data(service_client, get_repositories, get_repository):
get_repositories.return_value = future_repositories
get_repository.return_value = future_repository
mock_response = Mock()
mock_response.body = '{"errors": [{"source_id_type": "", "message": "not supported asset id type"}]}'
mock_response.code = 400
exc = httpclient.HTTPError(400, response=mock_response)
service_client.return_value = make_future(MagicMock())
client = yield service_client()
endpoint = client.repository.repositories[''].search.offers
endpoint.post.side_effect = exc
handler = _create_offers_handler()
# MUT
handler.request.body = (
'[{"source_id":' +
'"https://openpermissions.org/s0/hub1/asset/exampleco/ExampleCoPictureID/1",'
+ '"source_id_type":""}]')
with pytest.raises(HTTPError) as excinfo:
handler.post().result()
assert excinfo.value.status_code == mock_response.code
assert excinfo.value.errors == json.loads(mock_response.body)
def test_handle_error_signal(self):
if not signals_available:
# This test requires the blinker lib to run.
print("Can't test signals without signal support")
return
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 400
exception.data = {'foo': 'bar'}
recorded = []
def record(sender, exception):
recorded.append(exception)
got_request_exception.connect(record, app)
try:
with app.test_request_context("/foo"):
api.handle_error(exception)
self.assertEquals(len(recorded), 1)
self.assertTrue(exception is recorded[0])
finally:
got_request_exception.disconnect(record, app)
def test_onionoo_too_many_answers(self):
agent = Mock()
resp = Mock()
resp.code = 200
def feed_response(protocol):
config = {
"relays": [
{
"fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702",
},
{
"fingerprint": "boom",
}
]
}
protocol.dataReceived(json.dumps(config).encode())
protocol.connectionLost(Failure(ResponseDone()))
resp.deliverBody = Mock(side_effect=feed_response)
agent.request = Mock(return_value=defer.succeed(resp))
with self.assertRaises(Exception) as ctx:
yield self.router.get_onionoo_details(agent)
self.assertTrue(
"multiple relays for" in str(ctx.exception)
)
def dummy_balance_code():
m = Mock()
m.pk = random.randint(1, 999)
m.value = 100
m.code = generate_balance_code()
m.refill_series.pk = random.randint(1, 99)
m.refill_series.least_valid_until = date.today()
return m
def dummy_balance_code():
m = Mock()
m.pk = random.randint(1, 999)
m.value = 100
m.code = generate_balance_code()
m.refill_series.pk = random.randint(1, 99)
m.refill_series.least_valid_until = date.today()
return m
def setUp(self):
loc_tree = Mock()
loc_tree.get_hierarchy_path.return_value = ['hierarchy']
dbm = Mock(spec=DatabaseManager)
form_model = Mock(spec=FormModel)
location_field = Mock(spec=HierarchyField)
form_model.get_field_by_name.return_value= location_field
location_field.code='l'
self.registration_workflow = RegistrationWorkFlow(dbm, form_model, loc_tree)
def test_onionoo_get_fails(self):
agent = Mock()
resp = Mock()
resp.code = 500
agent.request = Mock(return_value=defer.succeed(resp))
with self.assertRaises(Exception) as ctx:
yield self.router.get_onionoo_details(agent)
self.assertTrue("Failed to lookup" in str(ctx.exception))
def test_call(self, treq_mock):
"""A call to a Mandrill API endpoint will return a deferred."""
response_mock = Mock()
response_mock.json.return_value = {'some': 'response'}
response_mock.code = 200
treq_mock.post.return_value = succeed(response_mock)
m = TXMandrill('nah')
result = yield m.users.info()
self.assertEquals(result, {'some': 'response'})
def test_call(self, treq_mock):
"""A call to a Mandrill API endpoint will return a deferred."""
response_mock = Mock()
response_mock.json.return_value = {'some': 'response'}
response_mock.code = 200
treq_mock.post.return_value = succeed(response_mock)
m = TXMandrill('nah')
result = yield m.users.info()
self.assertEquals(result, {'some': 'response'})
def test_generate_key_module(self):
""" Test that a key is generated for module functions """
def test_func(): pass
stat = Mock()
stat.code = test_func.__code__
expected_key = "%s.%s" % (self.__module__, stat.code.co_name)
key = linesman._generate_key(stat)
assert_equals(key, expected_key)
def test_generate_key_unknown(self):
""" Test that unknown module functions return as strings """
def test_func(): pass
stat = Mock()
stat.code = test_func.__code__
expected_key = "%s.%s" % (stat.code.co_filename, stat.code.co_name)
key = linesman._generate_key(stat)
assert_equals(key, expected_key)
def test_299_code(self, mock_urlopen):
result = Mock()
result.code = 299
result.getheaders.return_value = [(u'Content-Type', u'text/plain')]
result.read.side_effect = ['response']
mock_urlopen.return_value = result
requester = Requester('test', 'Test/0.1')
res = requester.request('https://test.test', {})
self.assertEqual(res, 'response')
def test_fetch_redirect_empty(self):
client = HTTPClient("http://example.com")
client.agent = Mock()
client.followRedirect = True
client.maxRedirects = 1
_response1 = Mock()
_response1.code = 302
_response1.headers.getAllRawHeaders.return_value = {}
_response1.deliverBody = lambda x: x.connectionLost(None)
_response2 = Mock()
_response2.code = 200
_response2.headers.getAllRawHeaders.return_value = {}
_response2.deliverBody = lambda x: x.connectionLost(None)
client.agent.request.side_effect = [
succeed(_response1),
succeed(_response2)
]
response = yield client.fetch()
self.assertEqual(response.body, "")
def test_failure(self, treq_mock):
"""An error HTTP response will raise an exception."""
response_mock = Mock()
response_mock.json.return_value = {
'name': 'ValidationError',
'status': 'error', 'message': 'Validation failed.'}
response_mock.code = 404
treq_mock.post.return_value = succeed(response_mock)
m = TXMandrill('nah')
yield self.assertFailure(m.users.info(), ValidationError)
def test_300_code(self, mock_urlopen):
result = Mock()
result.code = 300
result.getheaders.return_value = [(u'Content-Type', u'text/plain')]
result.read.side_effect = ['response']
mock_urlopen.return_value = result
requester = Requester('test', 'Test/0.1')
with self.assertRaises(ServerErrorException):
res = requester.request('https://test.test', {})
pass
def test_connect_while_connected(self, mock_endpoint):
"should pass http request body to TwitterStreamingProtocol"
mock_http_response = Mock()
mock_http_response.code = 200
mock_http_response.deliverBody = Mock()
self._connect(mock_endpoint, mock_http_response)
self.assertEquals(CONNECTED, self.stream.state)
with self.assertRaises(ValueError):
self.stream.track(TestReceiver(), ['track'])
def test_generate_key_module(self):
""" Test that a key is generated for module functions """
def test_func():
pass
stat = Mock()
stat.code = test_func.__code__
expected_key = "%s.%s" % (self.__module__, stat.code.co_name)
key = linesman._generate_key(stat)
assert_equals(key, expected_key)
def test_generate_key_unknown(self):
""" Test that unknown module functions return as strings """
def test_func():
pass
stat = Mock()
stat.code = test_func.__code__
expected_key = "%s.%s" % (stat.code.co_filename, stat.code.co_name)
key = linesman._generate_key(stat)
assert_equals(key, expected_key)
def test_onionoo_get_fails(self):
agent = Mock()
resp = Mock()
resp.code = 500
agent.request = Mock(return_value=defer.succeed(resp))
with self.assertRaises(Exception) as ctx:
yield self.router.get_onionoo_details(agent)
self.assertTrue(
"Failed to lookup" in str(ctx.exception)
)
def setup_urlopen(self, urlread_side_effect):
"""setup urlopen return value.
:param urlread_side_effect: a LIST of strings or exceptions returned by urlopen.read,
that will be converted to an itertools.cycle(side_effect) REMEMBER that any
element of urlread_side_effect which is a nonempty string must be followed by an
EMPTY STRINGS TO STOP reading otherwise we fall into an infinite loop if the
argument blocksize of url read is not negative !"""
self.mock_urlopen.reset_mock()
# convert returned values to the given urlread return value (tuple data, code, msg)
# if k is an int, convert to an HTTPError
retvals = []
# Check if we have an iterable (where strings are considered not iterables):
if not hasattr(urlread_side_effect, "__iter__") or \
isinstance(urlread_side_effect, (bytes, str)):
# it's not an iterable (wheere str/bytes/unicode are considered NOT iterable
# in both py2 and 3)
urlread_side_effect = [urlread_side_effect]
for k in urlread_side_effect:
a = Mock()
if type(k) == int:
a.read.side_effect = HTTPError('url', int(k), responses[k],
None, None)
elif type(k) in (bytes, str):
def func(k):
b = BytesIO(k.encode('utf8')
if type(k) == str else k) # py2to3 compatible
def rse(*a, **v):
rewind = not a and not v
if not rewind:
currpos = b.tell()
ret = b.read(*a, **v)
# hacky workaround to support cycle below: if reached the end,
# go back to start
if not rewind:
cp = b.tell()
rewind = cp == currpos
if rewind:
b.seek(0, 0)
return ret
return rse
a.read.side_effect = func(k)
a.code = 200
a.msg = responses[a.code]
else:
a.read.side_effect = k
retvals.append(a)
self.mock_urlopen.side_effect = cycle(retvals)
def test_handle_error_401_no_challenge_by_default(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context('/foo'):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
assert_false('WWW-Autheneticate' in resp.headers)
def test_handle_error_401_sends_challege_default_realm(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context('/foo'):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
self.assertEquals(resp.headers['WWW-Authenticate'],
'Basic realm="flask-restful"')
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
response = Mock()
response.code = http.OK
response.delivered_body = 'javascript!'
self.mocked_url_call = Mock(
side_effect=[succeed(response),
succeed(response)])
self.patch(ConversationConfigResource, 'load_source_from_url',
self.mocked_url_call)
self.config = self.vumi_helper.mk_config({
'worker_name': 'conversation_api_worker',
'web_path': '/foo/',
'web_port': 0,
'health_path': '/health/',
})
self.worker = yield self.vumi_helper.get_worker_helper().get_worker(
ConversationApiWorker, self.config)
self.addr = self.worker.webserver.getHost()
self.url = 'http://%s:%s%s' % (self.addr.host, self.addr.port,
self.config['web_path'])
self.user_helper = yield self.vumi_helper.make_user(u'user')
yield self.vumi_helper.setup_tagpool(u"pool", [u"tag1", u"tag2"])
yield self.user_helper.add_tagpool_permission(u"pool")
self.conversation = yield self.user_helper.create_conversation(
u'jsbox',
config={
'jsbox_app_config': {
'config': {
'source_url': 'http://configsourcecode/'
},
},
'jsbox': {
'source_url': 'http://sourcecode/',
},
'http_api': {
'api_tokens': ['token-1', 'token-2', 'token-3'],
'metrics_store': 'metrics_store'
},
})
self.auth_headers = {
'Authorization': [
'Basic ' +
base64.b64encode('%s:%s' %
(self.user_helper.account_key, 'token-1'))
],
}
def test_handle_error_401_sends_challege_default_realm(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context('/foo'):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
self.assertEquals(resp.headers['WWW-Authenticate'],
'Basic realm="flask-restful"')
def test_500_code(self, mock_urlopen):
result = Mock()
result.code = 500
result.getheaders.return_value = [(u'Content-Type', u'text/plain')]
result.read.side_effect = ['error']
mock_urlopen.return_value = result
mock_urlopen.side_effect = HTTPError("https://test.test", 500, 'Internal Server Error', None, None)
requester = Requester('test', 'Test/0.1')
with self.assertRaises(ServerErrorException):
res = requester.request('https://test.test', {})
pass
def test_handle_error_with_code(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = "JSONResponseError"
exception.data = {'foo': 'bar'}
with app.test_request_context("/foo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 500)
self.assertEquals(resp.data.decode(), dumps({"status": 500, "message": "Internal Server Error"}))
def _create_mocked_response(self, code=200, notification='Received',
subscription='Active', device='Connected'):
response = Mock()
response.code = code
response.MOCKED_HEADERS = {
'X-NotificationStatus': [notification],
'X-SubscriptionStatus': [subscription],
'X-DeviceConnectionStatus': [device]
}
response.headers.getRawHeaders = Mock(
side_effect=lambda name: response.MOCKED_HEADERS.get(name))
return response
def test_successful_connection(self, mock_endpoint):
"should pass http request body to TwitterStreamingProtocol"
mock_http_response = Mock()
mock_http_response.code = 200
mock_http_response.deliverBody = Mock()
d = self._connect(mock_endpoint, mock_http_response)
self.assertEquals(CONNECTED, self.stream.state)
self.assertTrue(mock_http_response.deliverBody.called)
self.assertTrue(d.called)
def test_failure(self, treq_mock):
"""An error HTTP response will raise an exception."""
response_mock = Mock()
response_mock.json.return_value = {
'name': 'ValidationError',
'status': 'error',
'message': 'Validation failed.'
}
response_mock.code = 404
treq_mock.post.return_value = succeed(response_mock)
m = TXMandrill('nah')
yield self.assertFailure(m.users.info(), ValidationError)
def test_403_code(self, mock_urlopen):
result = Mock()
result.code = 403
result.getheaders.return_value = [(u'Content-Type', u'text/plain')]
result.read.side_effect = ['error']
mock_urlopen.return_value = result
mock_urlopen.side_effect = HTTPError("https://test.test", 403, 'Access Denied', None, None)
requester = Requester('test', 'Test/0.1')
with self.assertRaises(AccessDeniedException):
res = requester.request('https://test.test', {})
pass
def test_422_code(self, mock_urlopen):
result = Mock()
result.code = 422
result.getheaders.return_value = [(u'Content-Type', u'text/plain')]
result.read.side_effect = ['error']
mock_urlopen.return_value = result
mock_urlopen.side_effect = HTTPError("https://test.test", 422, 'Unprocessable Entity', None, None)
requester = Requester('test', 'Test/0.1')
with self.assertRaises(InvalidMacOrOuiException):
res = requester.request('https://test.test', {})
pass
def test_handle_error_401_sends_challege_configured_realm(self):
app = Flask(__name__)
app.config['HTTP_BASIC_AUTH_REALM'] = 'test-realm'
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context('/foo'):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
self.assertEquals(resp.headers['WWW-Authenticate'],
'Basic realm="test-realm"')
def test_handle_error_401_sends_challege_configured_realm(self):
app = Flask(__name__)
app.config['HTTP_BASIC_AUTH_REALM'] = 'test-realm'
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context('/foo'):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
self.assertEquals(resp.headers['WWW-Authenticate'],
'Basic realm="test-realm"')
def test_handle_error(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 400
exception.data = {'foo': 'bar'}
with app.test_request_context("/foo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 400)
self.assertEquals(resp.data, dumps({
'foo': 'bar',
}))
def test_handle_auth(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context("/foo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
self.assertEquals(resp.data.decode(), dumps({'foo': 'bar'}))
self.assertTrue('WWW-Authenticate' in resp.headers)
def test_handle_auth(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 401
exception.data = {'foo': 'bar'}
with app.test_request_context("/foo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 401)
self.assertEquals(resp.data.decode(), dumps({'foo': 'bar'}))
self.assertTrue('WWW-Authenticate' in resp.headers)
def test_raise_client_http_error():
error = Mock()
error.code = 404
errors = {
"status": 404,
"errors": [
{"source": "authentication", "message": "Organisation not found"}
]
}
error.response.body = json.dumps(errors)
with pytest.raises(HTTPError) as err:
remote.raise_client_http_error(error)
assert err.value.status_code == error.code
assert err.value.errors == errors
def test_handle_error(self):
app = Flask(__name__)
api = flask_restful.Api(app)
exception = Mock()
exception.code = 400
exception.data = {'foo': 'bar'}
with app.test_request_context("/foo"):
resp = api.handle_error(exception)
self.assertEquals(resp.status_code, 400)
self.assertEquals(resp.data.decode(), dumps({
'foo': 'bar',
}))
def test_handle_produce_response_transport_error(self, fake_retry):
m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
response = Mock()
response.code = 599
response.error = object()
response.request = Mock()
response.request._batch = [m1, m2]
response.request._id = 1
self.producer._handle_produce_response('test_driver', response)
self.client.mock_for('response_5xx').assert_called_once_with('test_driver', response)
fake_retry.assert_has_calls([call('test_driver', m1),
call('test_driver', m2)])
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
response = Mock()
response.code = http.OK
response.delivered_body = 'javascript!'
self.mocked_url_call = Mock(
side_effect=[succeed(response), succeed(response)])
self.patch(ConversationConfigResource, 'load_source_from_url',
self.mocked_url_call)
self.config = self.vumi_helper.mk_config({
'worker_name': 'conversation_api_worker',
'web_path': '/foo/',
'web_port': 0,
'health_path': '/health/',
})
self.worker = yield self.vumi_helper.get_worker_helper().get_worker(
ConversationApiWorker, self.config)
self.addr = self.worker.webserver.getHost()
self.url = 'http://%s:%s%s' % (
self.addr.host, self.addr.port, self.config['web_path'])
self.user_helper = yield self.vumi_helper.make_user(u'user')
yield self.vumi_helper.setup_tagpool(u"pool", [u"tag1", u"tag2"])
yield self.user_helper.add_tagpool_permission(u"pool")
self.conversation = yield self.user_helper.create_conversation(
u'jsbox', config={
'jsbox_app_config': {
'config': {'source_url': 'http://configsourcecode/'},
},
'jsbox': {
'source_url': 'http://sourcecode/',
},
'http_api': {
'api_tokens': ['token-1', 'token-2', 'token-3'],
'metrics_store': 'metrics_store'
},
})
self.auth_headers = {
'Authorization': [
'Basic ' + base64.b64encode(
'%s:%s' % (self.user_helper.account_key, 'token-1'))
],
}
def test_handle_http_response():
response = Mock(HTTPResponse)
response.status = 200
response.code = 'OK'
response.content_type = 'text/html'
response.content_length = 1234
response.content = '<html><body>hi</body></html>'
value = handle_http_response(response)
content_array = [
'HTTP/1.1 200 OK',
'Content-Type: text/html',
'Content-Length: 1234',
'Server: Ocean/0.1.1',
'',
'<html><body>hi</body></html>'
]
assert value == '\n'.join(content_array)
def test_handle_produce_response_on_200(self, fake_decode, fake_handle_success):
m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
response = Mock()
response.code = 200
response.error = False
response.request = Mock()
response.request._batch = [m1, m2]
response.request._id = 1
body = {'offsets': [{}, {}],
'value_schema_id': 1,
'key_schema_id': 2}
fake_decode.return_value = body
self.producer._handle_produce_response('test_driver', response)
fake_handle_success.assert_called_once_with('test_driver',
response,
body)
def test_route_to_busy_node_saves_looks_up_and_send_check_fails(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.clear_node.called)
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_handle_produce_response_on_retriable(self, fake_decode, fake_retry):
m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
response = Mock()
response.code = 500
response.error = False
response.request = Mock()
response.request._batch = [m1, m2]
response.request._id = 1
body = {'offsets': [{}, {}],
'value_schema_id': 1,
'key_schema_id': 2,
'error_code': 50001,
'message': 'Retriable'}
fake_decode.return_value = body
self.producer._handle_produce_response('test_driver', response)
fake_retry.assert_has_calls([call('test_driver', m1),
call('test_driver', m2)])
def test_onionoo_success(self):
agent = Mock()
resp = Mock()
resp.code = 200
def feed_response(protocol):
config = {
"relays": [
{
"fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702",
},
]
}
protocol.dataReceived(json.dumps(config).encode())
protocol.connectionLost(Failure(ResponseDone()))
resp.deliverBody = Mock(side_effect=feed_response)
agent.request = Mock(return_value=defer.succeed(resp))
data = yield self.router.get_onionoo_details(agent)
self.assertTrue('fingerprint' in data)
self.assertTrue(data['fingerprint'] == "00786E43CCC5409753F25E36031C5CEA6EA43702")
