def test_message_count(self):
stanza1 = Mock()
stanza1.body = "a"
stanza2 = Mock()
stanza2.body = "a"
us = UserStats("user4")
us.update(stanza1)
us.update(stanza2)
self.assertEqual(us.message_count, 2)
def test_duplicate_unique_bodies_are_not_reflected(self):
stanza1 = Mock()
stanza1.body = "a"
stanza2 = Mock()
stanza2.body = "a"
us = UserStats("user3")
us.update(stanza1)
us.update(stanza2)
self.assertEqual(us.unique_bodies, set({"a"}))
def test_unique_recipients(self):
stanza1 = Mock()
stanza1.body = "a"
stanza1.recipient = "R"
stanza2 = Mock()
stanza2.body = "a"
stanza2.recipient = "Q"
us = UserStats("user5")
us.update(stanza1)
us.update(stanza2)
self.assertEqual(len(us.unique_recipients), 2)
def test_unique_bodies_are_updated(self):
stanza = Mock()
stanza.body = "a"
us = UserStats("user2")
us.update(stanza)
self.assertEqual(us.unique_bodies, set({"a"}))
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_create_item_invalidresource(self):
'''This test case ensures an item can not be created if it's invalid.'''
resource = Resource(name="Mock Simple Resource",
url="/mock-simple-resources",
version=1.0,
validator=MockSimpleResourceValidator)
resource(MockSimpleResourceRoa, self._resources_registry)
request_body = {"description": "Simple resource description."}
request = Mock()
request.body = json.dumps(request_body).encode()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(
return_value=MockSimpleResourceRoa(
description=request_body.get("description")))
response = self._controller.create_item(request,
version=str(resource.version),
resource_url=resource.url)
self._assert_resource_error(response, 400, 10010,
str(resource.version), resource.url)
self._resources_registry.find_by_url.assert_called_once_with(
resource.url, resource.version)
self._json_serializer.deserialize.assert_called_once_with(
request.body.decode())
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_request_kwargs(service_account_response): # noqa: F811
# type: (Dict[Text, Any]) -> None
mock_fetch = Mock()
resp = Mock()
resp.body = json.dumps(service_account_response)
def check_request_obj(request):
# type: (HTTPRequest) -> Mock
assert request.user_agent == "a string"
assert request.follow_redirects is False
return resp
mock_fetch.side_effect = check_request_obj
with patch.object(HTTPClient, "fetch", mock_fetch):
# Confirm basic HTTPRequest construction with kwargs works
http_req_kwargs = {"user_agent": "a string", "follow_redirects": False}
client = Groupy(["localhost:8000"], request_kwargs=http_req_kwargs)
client.users.get("*****@*****.**")
assert mock_fetch.call_count == 1
# Confirm overwriting kwargs in individual _fetch calls works
with pytest.raises(AssertionError):
client._fetch("/some/path", user_agent="a different string")
assert mock_fetch.call_count == 2
def test_update_item_itemnotfound(self):
'''This test case covers scenario when we want to update an item which does not exist.'''
expected_body = {"name": "cool name",
"description": "incredible simple description"}
url = "/simple-resources"
version = "1.0"
resource_id = "12345"
request = Mock()
request.body = json.dumps(expected_body).encode()
resource = Resource(name="Mock Simple Resource", url=url,
version=float(version))
resource(MockSimpleResourceRoa, self._resources_registry)
pk_col = MockSimpleResourceRoa.id
model = Mock()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(return_value=model)
self._model_facade.find_by_pk = Mock(return_value=None)
self._model_facade.model_pk_cols = [pk_col]
response = self._controller.update_item(request, version, url, resource_id)
self._assert_resource_error(response, 404, 10040, version, url)
self._resources_registry.find_by_url.assert_called_once_with(url, float(version))
self._model_facade.find_by_pk.assert_called_once_with({MockSimpleResourceRoa.id: resource_id})
self._json_serializer_cls.assert_called_once_with(resource)
self._json_serializer.deserialize.assert_called_once_with(json.dumps(expected_body))
def get_signed_grade_mock_request_with_correct_signature(self):
"""
Generate a proper LTI request object
"""
mock_request = Mock()
mock_request.headers = {
'X-Requested-With': 'XMLHttpRequest',
'Content-Type': 'application/x-www-form-urlencoded',
'Authorization': (
u'OAuth realm="https://testurl/", oauth_body_hash="wwzA3s8gScKD1VpJ7jMt9b%2BMj9Q%3D",'
'oauth_nonce="18821463", oauth_timestamp="1409321145", '
'oauth_consumer_key="__consumer_key__", oauth_signature_method="HMAC-SHA1", '
'oauth_version="1.0", oauth_signature="fHsE1hhIz76/msUoMR3Lyb7Aou4%3D"'
)
}
mock_request.url = u'https://testurl'
mock_request.http_method = u'POST'
mock_request.method = mock_request.http_method
mock_request.body = (
'<?xml version=\'1.0\' encoding=\'utf-8\'?>\n'
'<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">'
'<imsx_POXHeader><imsx_POXRequestHeaderInfo><imsx_version>V1.0</imsx_version>'
'<imsx_messageIdentifier>edX_fix</imsx_messageIdentifier></imsx_POXRequestHeaderInfo>'
'</imsx_POXHeader><imsx_POXBody><replaceResultRequest><resultRecord><sourcedGUID>'
'<sourcedId>MITxLTI/MITxLTI/201x:localhost%3A8000-i4x-MITxLTI-MITxLTI-lti-3751833a214a4f66a0d18f63234207f2:363979ef768ca171b50f9d1bfb322131</sourcedId>' # pylint: disable=line-too-long
'</sourcedGUID><result><resultScore><language>en</language><textString>0.32</textString></resultScore>'
'</result></resultRecord></replaceResultRequest></imsx_POXBody></imsx_POXEnvelopeRequest>'
)
return mock_request
def get_signed_grade_mock_request(self, namespace_lti_v1p1=True):
"""
Example of signed request from LTI Provider.
When `namespace_v1p0` is set to True then the default namespase from
LTI 1.1 will be used. Otherwise fake namespace will be added to XML.
"""
mock_request = Mock()
mock_request.headers = {
'X-Requested-With':
'XMLHttpRequest',
'Content-Type':
'application/x-www-form-urlencoded',
'Authorization':
u'OAuth oauth_nonce="135685044251684026041377608307", \
oauth_timestamp="1234567890", oauth_version="1.0", \
oauth_signature_method="HMAC-SHA1", \
oauth_consumer_key="test_client_key", \
oauth_signature="my_signature%3D", \
oauth_body_hash="JEpIArlNCeV4ceXxric8gJQCnBw="'
}
mock_request.url = u'http://testurl'
mock_request.http_method = u'POST'
params = {}
if not namespace_lti_v1p1:
params = {'namespace': "http://www.fakenamespace.com/fake"}
mock_request.body = self.get_request_body(params)
return mock_request
def test_create_item_dbexception(self):
'''This test case ensures an error response is received if an unexpected db error occurs when creating the resource.'''
resource = Resource(name="Mock Simple Resource",
url="/mock-simple-resources",
version=1.0)
resource(MockSimpleResourceRoa, self._resources_registry)
request_body = {
"name": "simple-resource1",
"description": "Simple resource description."
}
expected_model = MockSimpleResourceRoa(
name=request_body.get("name"),
description=request_body.get("description"))
request = Mock()
request.body = json.dumps(request_body).encode()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(return_value=expected_model)
self._model_facade.create = Mock(
side_effect=FantasticoDbError("Unexpected db error."))
response = self._controller.create_item_latest(request, resource.url)
self._assert_resource_error(response, 400, 10030,
str(resource.version), resource.url)
self._resources_registry.find_by_url.assert_called_once_with(
resource.url, "latest")
self._json_serializer.deserialize.assert_called_once_with(
request.body.decode())
self._model_facade.create.assert_called_once_with(expected_model)
def get_signed_grade_mock_request(self):
"""
Example of signed request from LTI Provider.
"""
mock_request = Mock()
mock_request.headers = {
'X-Requested-With':
'XMLHttpRequest',
'Content-Type':
'application/xml',
'Authorization':
u'OAuth oauth_nonce="135685044251684026041377608307", \
oauth_timestamp="1234567890", oauth_version="1.0", \
oauth_signature_method="HMAC-SHA1", \
oauth_consumer_key="test_client_key", \
oauth_signature="my_signature%3D", \
oauth_body_hash="gz+PeJZuF2//n9hNUnDj2v5kN70="'
}
mock_request.url = u'http://testurl'
mock_request.http_method = u'POST'
mock_request.body = textwrap.dedent("""
<?xml version = "1.0" encoding = "UTF-8"?>
<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">
</imsx_POXEnvelopeRequest>
""")
return mock_request
def test_call(self):
body = "body"
headers = {"header": "value"}
path = "/authorize"
status_code = 200
http_code = "200 OK"
environment = {"PATH_INFO": path, "myvar": "value"}
request_mock = Mock(spec=Request)
request_class_mock = Mock(return_value=request_mock)
response_mock = Mock(spec=Response)
response_mock.body = body
response_mock.headers = headers
response_mock.status_code = status_code
server_mock = Mock(spec=Provider)
server_mock.dispatch.return_value = response_mock
start_response_mock = Mock()
wsgi = Wsgi(server=server_mock,
authorize_uri=path,
request_class=request_class_mock,
env_vars=["myvar"])
result = wsgi(environment, start_response_mock)
request_class_mock.assert_called_with(environment)
server_mock.dispatch.assert_called_with(request_mock,
{"myvar": "value"})
start_response_mock.assert_called_with(http_code,
list(headers.items()))
self.assertEqual(result, [body.encode('utf-8')])
def test_create_item_dbexception(self):
'''This test case ensures an error response is received if an unexpected db error occurs when creating the resource.'''
resource = Resource(name="Mock Simple Resource", url="/mock-simple-resources",
version=1.0)
resource(MockSimpleResourceRoa, self._resources_registry)
request_body = {"name": "simple-resource1",
"description": "Simple resource description."}
expected_model = MockSimpleResourceRoa(name=request_body.get("name"),
description=request_body.get("description"))
request = Mock()
request.body = json.dumps(request_body).encode()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(return_value=expected_model)
self._model_facade.create = Mock(side_effect=FantasticoDbError("Unexpected db error."))
response = self._controller.create_item_latest(request, resource.url)
self._assert_resource_error(response, 400, 10030, str(resource.version), resource.url)
self._resources_registry.find_by_url.assert_called_once_with(resource.url, "latest")
self._json_serializer.deserialize.assert_called_once_with(request.body.decode())
self._model_facade.create.assert_called_once_with(expected_model)
def test_update_item_resource_invalid(self):
'''This test case ensures an item is not updated if it fails validation.'''
expected_body = {}
url = "/simple-resources"
version = "1.0"
resource = Resource(name="Mock Simple Resource", url=url,
version=float(version),
validator=MockSimpleResourceValidator)
resource(MockSimpleResourceRoa, self._resources_registry)
resource_id = 1986
request = Mock()
request.body = json.dumps(expected_body).encode()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(return_value=MockSimpleResourceRoa())
response = self._controller.update_item(request, version, url, resource_id)
self._assert_resource_error(response, 400, 10010, version, url)
self._resources_registry.find_by_url.assert_called_once_with(url, float(version))
self._json_serializer.deserialize.assert_called_once_with(json.dumps(expected_body))
def test_password_in_batched_json(self):
mock_request = Mock()
mock_request.META = {
DJANGO_META_CONTENT_TYPE: 'application/json; charset=UTF-8'
}
d = [{
'x': 'testunmasked',
'username': '******',
'password': '******'
}, {
'x': 'testunmasked',
'username': '******',
'password': '******'
}]
mock_request.body = json.dumps(d)
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertIn('testunmasked', raw_body)
self.assertNotIn('test_username', raw_body)
self.assertNotIn('testpassword', raw_body)
self.assertNotIn('test_username', body[0])
self.assertNotIn('testpassword', body[0])
self.assertNotIn('test_username', body[1])
self.assertNotIn('testpassword', body[1])
for data in [json.loads(body), json.loads(raw_body)]:
for datum in data:
self.assertEqual(datum['username'],
RequestModelFactory.CLEANSED_SUBSTITUTE)
self.assertEqual(datum['password'],
RequestModelFactory.CLEANSED_SUBSTITUTE)
self.assertEqual(datum['x'], 'testunmasked')
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 get_signed_grade_mock_request_with_correct_signature(self):
"""
Generate a proper LTI request object
"""
mock_request = Mock()
mock_request.headers = {
u'X-Requested-With':
u'XMLHttpRequest',
u'Content-Type':
u'application/x-www-form-urlencoded',
u'Authorization':
(u'OAuth realm="https://testurl/", oauth_body_hash="wwzA3s8gScKD1VpJ7jMt9b%2BMj9Q%3D",'
u'oauth_nonce="18821463", oauth_timestamp="1409321145", '
u'oauth_consumer_key="__consumer_key__", oauth_signature_method="HMAC-SHA1", '
u'oauth_version="1.0", oauth_signature="fHsE1hhIz76/msUoMR3Lyb7Aou4%3D"'
)
}
mock_request.url = u'https://testurl'
mock_request.http_method = u'POST'
mock_request.method = mock_request.http_method
mock_request.body = (
u'<?xml version=\'1.0\' encoding=\'utf-8\'?>\n'
u'<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">'
u'<imsx_POXHeader><imsx_POXRequestHeaderInfo><imsx_version>V1.0</imsx_version>'
u'<imsx_messageIdentifier>edX_fix</imsx_messageIdentifier></imsx_POXRequestHeaderInfo>'
u'</imsx_POXHeader><imsx_POXBody><replaceResultRequest><resultRecord><sourcedGUID>'
u'<sourcedId>MITxLTI/MITxLTI/201x:localhost%3A8000-i4x-MITxLTI-MITxLTI-lti-3751833a214a4f66a0d18f63234207f2'
u':363979ef768ca171b50f9d1bfb322131</sourcedId>'
u'</sourcedGUID><result><resultScore><language>en</language><textString>0.32</textString></resultScore>'
u'</result></resultRecord></replaceResultRequest></imsx_POXBody></imsx_POXEnvelopeRequest>'
).encode('utf-8')
return mock_request
def get_signed_grade_mock_request(self, namespace_lti_v1p1=True):
"""
Example of signed request from LTI Provider.
When `namespace_v1p0` is set to True then the default namespase from
LTI 1.1 will be used. Otherwise fake namespace will be added to XML.
"""
mock_request = Mock()
mock_request.headers = {
'X-Requested-With': 'XMLHttpRequest',
'Content-Type': 'application/x-www-form-urlencoded',
'Authorization': u'OAuth oauth_nonce="135685044251684026041377608307", \
oauth_timestamp="1234567890", oauth_version="1.0", \
oauth_signature_method="HMAC-SHA1", \
oauth_consumer_key="test_client_key", \
oauth_signature="my_signature%3D", \
oauth_body_hash="JEpIArlNCeV4ceXxric8gJQCnBw="'
}
mock_request.url = u'http://testurl'
mock_request.http_method = u'POST'
params = {}
if not namespace_lti_v1p1:
params = {
'namespace': "http://www.fakenamespace.com/fake"
}
mock_request.body = self.get_request_body(params)
return mock_request
def _get_email_mock(self, body, subject):
email = Mock()
email.body = body
email.subject = subject
return email
def test_update_item_resource_invalid(self):
'''This test case ensures an item is not updated if it fails validation.'''
expected_body = {}
url = "/simple-resources"
version = "1.0"
resource = Resource(name="Mock Simple Resource",
url=url,
version=float(version),
validator=MockSimpleResourceValidator)
resource(MockSimpleResourceRoa, self._resources_registry)
resource_id = 1986
request = Mock()
request.body = json.dumps(expected_body).encode()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(
return_value=MockSimpleResourceRoa())
response = self._controller.update_item(request, version, url,
resource_id)
self._assert_resource_error(response, 400, 10010, version, url)
self._resources_registry.find_by_url.assert_called_once_with(
url, float(version))
self._json_serializer.deserialize.assert_called_once_with(
json.dumps(expected_body))
def test_update_item_dbex(self):
'''This test case covers scenario when an item can not be updated because of a db exception.'''
expected_body = {"name": "cool name",
"description": "incredible simple description"}
url = "/simple-resources"
version = "1.0"
resource_id = "12345"
request = Mock()
request.body = json.dumps(expected_body).encode()
resource = Resource(name="Mock Simple Resource", url=url,
version=float(version))
resource(MockSimpleResourceRoa, self._resources_registry)
pk_col = Mock()
pk_col.name = "id"
model = Mock()
self._resources_registry.find_by_url = Mock(return_value=resource)
self._json_serializer.deserialize = Mock(return_value=model)
self._model_facade.update = Mock(side_effect=FantasticoDbError("Unexpected exception"))
self._model_facade.model_pk_cols = [pk_col]
response = self._controller.update_item(request, version, url, resource_id)
self._assert_resource_error(response, 400, 10030, version, url)
self.assertEqual(resource_id, model.id)
self._resources_registry.find_by_url.assert_called_once_with(url, float(version))
self._json_serializer_cls.assert_called_once_with(resource)
self._json_serializer.deserialize.assert_called_once_with(json.dumps(expected_body))
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_respond_to_detection_response(self):
sender = MagicMock()
detect = MagicMock()
detect.respond_to_detection_response = Mock(return_value="something_to_send")
context = MagicMock()
suggest = Mock()
target = Target(sender, detect, context, suggest)
target.json_decode = MagicMock(return_value="decode_detection_response")
response = Mock()
response.body = "response_body"
handler = Mock()
handler.context_id = "context_id_value"
target.get_detect_callback(response, handler, "message_value")
target.json_decode.assert_called_once_with("response_body")
# context.post_context_message.assert_called_once_with("context_id_value", 1, "", dection="decode_detection_response")
self.assertEqual(1, context.post_context_message.call_count)
self.assertEqual("context_id_value", context.post_context_message.call_args_list[0][0][0])
self.assertEqual(1, context.post_context_message.call_args_list[0][0][1])
self.assertEqual("", context.post_context_message.call_args_list[0][0][2])
self.assertEqual("decode_detection_response", context.post_context_message.call_args_list[0][1]["detection"])
detect.respond_to_detection_response.assert_called_once_with(handler, "decode_detection_response")
sender.write_jemboo_response_message.assert_called_once_with(handler, "something_to_send")
def test_call(self):
body = "body"
headers = {"header": "value"}
path = "/authorize"
status_code = 200
http_code = "200 OK"
environment = {"PATH_INFO": path, "myvar": "value"}
request_mock = Mock(spec=Request)
request_class_mock = Mock(return_value=request_mock)
responseMock = Mock(spec=Response)
responseMock.body = body
responseMock.headers = headers
responseMock.status_code = status_code
server_mock = Mock(spec=Provider)
server_mock.dispatch.return_value = responseMock
start_response_mock = Mock()
wsgi = Wsgi(server=server_mock, authorize_uri=path,
request_class=request_class_mock, env_vars=["myvar"])
result = wsgi(environment, start_response_mock)
request_class_mock.assert_called_with(environment)
server_mock.dispatch.assert_called_with(request_mock,
{"myvar": "value"})
start_response_mock.assert_called_with(http_code, headers.items())
self.assertEqual(result, [body])
def test_update_item_nobody(self):
'''This test case ensures an item can not be updated without passing a body.'''
url = "/simple-resources"
version = "1.0"
resource = Resource(name="Mock Simple Resource",
url=url,
version=float(version))
resource(MockSimpleResourceRoa, self._resources_registry)
resource_id = 1986
request = Mock()
request.body = None
self._resources_registry.find_by_url = Mock(return_value=resource)
response = self._controller.update_item(request, version, url,
resource_id)
self._assert_resource_error(response, 400, 10020, version, url)
self._resources_registry.find_by_url.assert_called_once_with(
url, float(version))
def test_password_in_batched_json(self):
mock_request = Mock()
mock_request.META = {
DJANGO_META_CONTENT_TYPE: 'application/json; charset=UTF-8'
}
d = [{
'x': 'testunmasked',
'username': '******',
'password': '******'
}, {
'x': 'testunmasked',
'username': '******',
'password': '******'
}]
mock_request.body = json.dumps(d)
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertIn('testunmasked', raw_body)
self.assertNotIn('test_username', raw_body)
self.assertNotIn('testpassword', raw_body)
self.assertNotIn('test_username', body[0])
self.assertNotIn('testpassword', body[0])
self.assertNotIn('test_username', body[1])
self.assertNotIn('testpassword', body[1])
def test_regular(self):
sender = MagicMock()
detect = MagicMock()
context = MagicMock()
suggest = Mock()
target = Target(sender, detect, context, suggest)
target.json_decode = MagicMock(return_value={"_rev": "context_revision_value"})
target.context_responder.unsupported_entities = MagicMock()
response = Mock()
response.body = "response_body_value"
handler = MagicMock()
handler.user_id = "user_id_value"
handler.application_id = "application_id_value"
handler.session_id = "session_id_value"
handler.locale = "locale_value"
target.get_context_callback(response, handler, "message_value")
target.json_decode.assert_called_once_with("response_body_value")
target.context_responder.unsupported_entities.assert_called_once_with(
handler, {"_rev": "context_revision_value"}
)
self.assertEqual(1, suggest.post_suggest.call_count)
self.assertEqual("user_id_value", suggest.post_suggest.call_args_list[0][0][0])
self.assertEqual("application_id_value", suggest.post_suggest.call_args_list[0][0][1])
self.assertEqual("session_id_value", suggest.post_suggest.call_args_list[0][0][2])
self.assertEqual("locale_value", suggest.post_suggest.call_args_list[0][0][3])
self.assertDictEqual({"_rev": "context_revision_value"}, suggest.post_suggest.call_args_list[0][0][4])
def test_exists_false():
db = create_mockdb()
response = Mock()
response.body = '{"boolean":false}'
db.query.return_value = make_future(response)
entity_id = 'e321111e118'
result = yield asset.exists(db, entity_id)
assert result is False
def fetch(self, url, *args, **kwargs):
response = Mock()
# Imitate a tornado.httpclient.httpresponse
response.body = '{"associated_implicit_registration_sets": ["abc"]}'
response.headers.get_list.return_value = [
'/irs/irs-uuid/service_profiles/sp-uuid'
]
return response
def request_wrap(data: dict):
"""
Wrapper for sending data to a json handler
"""
request = Mock()
request.method = "POST"
request.body = json.dumps(data).encode("utf-8")
return request
def test_dump_body_buffer(self):
msg = Mock()
msg.body = 'str'
try:
buf = buffer(msg.body)
except NameError:
raise SkipTest('buffer type not available')
self.assertTrue(dump_body(msg, buf))
def test_dump_body_buffer(self):
msg = Mock()
msg.body = 'str'
try:
buf = buffer(msg.body)
except NameError:
raise SkipTest('buffer type not available')
self.assertTrue(dump_body(msg, buf))
def test_payment_already_paid(self):
payment = mommy.make(getpaid.models.Payment, id=90, amount=119000, paid_on=now())
request = Mock()
request.POST = {'TBK_MONTO': '11900000'}
request.body = self.QUOTED_REQUEST_BODY
self.assertFalse(PaymentProcessor.validate(payment, request))
def test_max_request(self):
SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = 10 # 10kb
mock_request = Mock()
mock_request.META = {'CONTENT_TYPE': 'text/plain'}
mock_request.GET = {}
mock_request.body = 'a'.encode('ascii') * 1024 * 100 # 100kb
request_model = RequestModelFactory(mock_request).construct_request_model()
self.assertFalse(request_model.raw_body)
def test_cube_desc():
response = Mock()
response.body = []
response.headers = {}
Client.fetch = Mock(return_value=response)
v1 = kylinpy.Kylinpy(host='host',
username='******',
password='******',
version='v1').cube_desc('cube_name')
response = Mock()
response.body = {'data': {'cube': []}, 'code': 000, 'msg': ''}
response.headers = {}
v2 = kylinpy.Kylinpy(host='host',
username='******',
password='******',
version='v2').cube_desc('cube_name')
assert v1 == v2
def test_plain(self):
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'text/plain'}
mock_request.body = 'sdfsdf'
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertFalse(body)
self.assertEqual(raw_body, mock_request.body)
def test_plain(self):
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'text/plain'}
mock_request.body = 'sdfsdf'
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertFalse(body)
self.assertEqual(raw_body, mock_request.body)
def test_exists_query_called():
db = create_mockdb()
response = Mock()
response.body = '{"boolean":true}'
db.query.return_value = make_future(response)
entity_id = 'e3a2221e118'
assert db.query.call_count == 0
yield asset.exists(db, entity_id)
assert db.query.call_count == 1
def test_max_request(self):
SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = 10 # 10kb
mock_request = Mock()
mock_request.META = {"CONTENT_TYPE": "text/plain"}
mock_request.GET = {}
mock_request.body = "a".encode("ascii") * 1024 * 100 # 100kb
mock_request.path = reverse("silk:requests")
request_model = RequestModelFactory(mock_request).construct_request_model()
self.assertFalse(request_model.raw_body)
def test_no_max_request(self):
SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = -1
mock_request = Mock()
mock_request.META = {'CONTENT_TYPE': 'text/plain'}
mock_request.GET = {}
mock_request.body = 'a'.encode('ascii') * 1000 # 1000 bytes?
request_model = RequestModelFactory(
mock_request).construct_request_model()
self.assertTrue(request_model.raw_body)
def test_no_max_request(self):
SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = -1
mock_request = Mock()
mock_request.META = {'CONTENT_TYPE': 'text/plain'}
mock_request.GET = {}
mock_request.path = reverse('silk:requests')
mock_request.method = 'get'
mock_request.body = 'a'.encode('ascii') * 1000 # 1000 bytes?
request_model = RequestModelFactory(mock_request).construct_request_model()
self.assertTrue(request_model.raw_body)
def func3():
response = Mock()
response.body = json.dumps({
"status": 400,
"errors": [
{"source": "onboarding",
"message": "missing asset_type"}
]
})
raise httpclient.HTTPError(400, 'doh', response)
def test_tables_and_columns():
response = Mock()
response.body = []
response.headers = {}
Client.fetch = Mock(return_value=response)
v1 = kylinpy.Kylinpy(host='host',
username='******',
password='******',
version='v1').tables_and_columns()
response = Mock()
response.body = {'data': [], 'code': 000, 'msg': ''}
response.headers = {}
Client.fetch = Mock(return_value=response)
v2 = kylinpy.Kylinpy(host='host',
username='******',
password='******',
version='v2').tables_and_columns()
assert v1 == v2
def test_utf_json_not_encoded(self):
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'application/json; charset=UTF-8'}
d = {'x': u'语'}
mock_request.body = json.dumps(d)
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertDictEqual(json.loads(body), d)
self.assertEqual(raw_body, mock_request.body)
def test_invalid_encoding_json(self):
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'application/json; charset=asdas-8'}
d = {'x': u'语'}
mock_request.body = json.dumps(d).encode('UTF-8')
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertDictEqual(json.loads(body, encoding='UTF-8'), d)
self.assertEqual(raw_body, raw_body)
def test_that_event_can_be_fetched_given_obfuscated_id(self,
mock_client_func):
mock_api_response = Mock()
mock_client_func.return_value = mock_api_response
mock_api_response.body = '{"event": "json"}'
eq_(bsd.BSDClient.fetch_event('obf_id'), {'event': 'json'})
mock_client_func.assert_called_with('/event/get_event_details',
{'values': json.dumps({'event_id_obfuscated': 'obf_id'})})
def mock_async_http_client():
p_return_value = Mock()
p_return_value.body = "{}"
p = patch("tornado.httpclient.AsyncHTTPClient")
p.return_value.fetch.return_value = create_future(p_return_value)
yield p.start()
p.stop()
def test__get_question_top_answer_body__answers():
Answer = namedtuple('Answer', ['id', 'score'])
answers = [Answer(1, 1), Answer(2, 2)]
so = Mock()
fetched_answer = Mock()
fetched_answer.body = "foobar"
so.answer.return_value = fetched_answer
question = Mock()
question.answers = answers
assert get_question_top_answer_body(so, question) == "foobar"
def test_utf_json_encoded_no_charset(self):
"""default to UTF-8"""
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'application/json'}
d = {'x': u'语'}
mock_request.body = json.dumps(d).encode('UTF-8')
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertDictEqual(json.loads(body), d)
self.assertEqual(raw_body, mock_request.body.decode('UTF-8'))
def test_that_organiser_email_can_be_added_as_constituent(self,
mock_client_func):
mock_api_response = Mock()
mock_client_func.return_value = mock_api_response
mock_api_response.http_status = 200
mock_api_response.body = '[{"cons_id" : 34, "email_id" : 234}]'
eq_(34, bsd.BSDClient.register_email_address_as_constituent('*****@*****.**'))
mock_client_func.assert_called_with('/cons/email_register',
{'email': '*****@*****.**', 'format': 'json'})
def test_cleanup_should_not_delete_other_stacks_messages(self):
message_body = (
'{ '
'"status": "UPDATE_COMPLETE", '
'"timestamp": "2015-11-24T13:14:16.575Z", '
'"stackName": "other-teststack", '
'"message": "User Initiated", '
'"emitter": "cloudformation", '
'"resourceType": "AWS::CloudFormation::Stack"}')
message = Mock()
message.body = message_body
self.assertIsNone(cleanup_old_messages(datetime.now(), message, 'my-teststack'))
def test_password_in_body(self):
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'text/plain'}
mock_request.body = 'username=test_username&unmasked=testunmasked&password=testpassword'
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertIn('testunmasked', raw_body)
self.assertNotIn('test_username', raw_body)
self.assertNotIn('testpassword', raw_body)
self.assertNotIn('test_username', body)
self.assertNotIn('testpassword', body)
def test_password_in_json(self):
mock_request = Mock()
mock_request.META = {DJANGO_META_CONTENT_TYPE: 'application/json; charset=UTF-8'}
d = {'x': 'testunmasked', 'username': '******', 'password': '******'}
mock_request.body = json.dumps(d)
mock_request.get = mock_request.META.get
factory = RequestModelFactory(mock_request)
body, raw_body = factory.body()
self.assertIn('testunmasked', raw_body)
self.assertNotIn('test_username', raw_body)
self.assertNotIn('testpassword', raw_body)
self.assertNotIn('test_username', body)
self.assertNotIn('testpassword', body)
