def test_parent_and_bound_data_are_preserved(self):
request = DummyRequest()
request.invoke_subrequest.side_effect = (httpexceptions.HTTPTemporaryRedirect, None)
subrequest = DummyRequest()
subrequest.parent = mock.sentinel.parent
subrequest.bound_data = mock.sentinel.bound_data
_, redirected = follow_subrequest(request, subrequest)
self.assertEqual(subrequest.parent, redirected.parent)
self.assertEqual(subrequest.bound_data, redirected.bound_data)
def assert_request_resolves_to(self,
method,
permission,
uri=None,
record_not_found=False):
if uri is None:
uri = self.record_uri
with mock.patch('kinto.core.utils.current_service') as current_service:
# Patch current service.
resource = mock.MagicMock()
resource.record_id = 1
if record_not_found:
resource.model.get_record.side_effect = \
storage_exceptions.RecordNotFoundError
else:
resource.model.get_record.return_value = 1
current_service().resource.return_value = resource
# Do the actual call.
request = DummyRequest(method=method)
request.upath_info = uri
context = RouteFactory(request)
self.assertEquals(context.required_permission, permission)
def setUp(self):
self.authz = AuthorizationPolicy()
self.authz.get_bound_permissions = lambda o, p: []
self.request = DummyRequest(method="GET")
self.context = RouteFactory(self.request)
self.context.on_plural_endpoint = True
self.context.check_permission = mock.Mock(return_value=False)
def test_fetch_shared_objects_sets_shared_ids_if_empty(self):
request = DummyRequest()
context = RouteFactory(request)
request.registry.permission.get_accessible_objects.return_value = {}
context.fetch_shared_objects("read", ["userid"], None)
self.assertEqual(context.shared_ids, [])
def test_send_alert_url_can_be_specified(self):
request = DummyRequest()
send_alert(request, "Message", "error_url")
self.verify_alert_header(request, {
"code": "soft-eol",
"message": "Message",
"url": "error_url"
})
def test_send_alert_url_can_be_specified(self):
request = DummyRequest()
send_alert(request, 'Message', 'error_url')
self.verify_alert_header(request, {
'code': 'soft-eol',
'message': 'Message',
'url': 'error_url'
})
def test_ping_returns_true_when_working(self):
request = DummyRequest()
request.headers['Authorization'] = 'Basic bWF0OjI='
ping = heartbeat(self.storage)
with mock.patch('kinto.core.storage.random.SystemRandom.random', return_value=0.7):
self.assertTrue(ping(request))
with mock.patch('kinto.core.storage.random.SystemRandom.random', return_value=0.5):
self.assertTrue(ping(request))
def test_fetch_shared_records_sets_shared_ids_to_none_if_empty(self):
request = DummyRequest()
context = RouteFactory(request)
request.registry.permission.get_accessible_objects.return_value = {}
context.fetch_shared_records('read', ['userid'], None)
self.assertIsNone(context.shared_ids)
def test_permits_takes_route_factory_allowed_principals_into_account_for_object_creation(self):
request = DummyRequest()
context = RouteFactory(request)
context._check_permission.return_value = False
context.resource_name = "book"
context.required_permission = "book:create"
context._settings = {"book_create_principals": "fxa:user"}
self.assertTrue(context.check_permission(["fxa:user"], None))
def test_ping_returns_false_if_unavailable_in_readonly_mode(self):
request = DummyRequest()
request.headers['Authorization'] = 'Basic bWF0OjI='
request.registry.settings = {'readonly': 'true'}
ping = heartbeat(self.storage)
with mock.patch.object(self.storage, 'get_all',
side_effect=exceptions.BackendError("Boom!")):
self.assertFalse(ping(request))
def test_send_alert_default_to_project_url(self):
request = DummyRequest()
request.registry.settings['project_docs'] = 'docs_url'
send_alert(request, 'Message')
self.verify_alert_header(request, {
'code': 'soft-eol',
'message': 'Message',
'url': 'docs_url'
})
def test_send_alert_default_to_project_url(self):
request = DummyRequest()
request.registry.settings["project_docs"] = "docs_url"
send_alert(request, "Message")
self.verify_alert_header(request, {
"code": "soft-eol",
"message": "Message",
"url": "docs_url"
})
def test_fetch_shared_records_sets_shared_ids_from_results(self):
request = DummyRequest()
context = RouteFactory(request)
request.registry.permission.get_accessible_objects.return_value = {
'/obj/1': ['read', 'write'],
'/obj/3': ['obj:create']
}
context.fetch_shared_records('read', ['userid'], None)
self.assertEquals(sorted(context.shared_ids), ['1', '3'])
def test_ping_logs_error_if_unavailable(self):
request = DummyRequest()
self.client_error_patcher.start()
ping = heartbeat(self.storage)
with mock.patch('kinto.core.storage.logger.exception') as exc_handler:
self.assertFalse(ping(request))
self.assertTrue(exc_handler.called)
def test_send_alert_code_can_be_specified(self):
request = DummyRequest()
request.registry.settings['project_docs'] = 'docs_url'
send_alert(request, 'Message', code='hard-eol')
self.verify_alert_header(request, {
'code': 'hard-eol',
'message': 'Message',
'url': 'docs_url'
})
def test_fetch_shared_objects_sets_shared_ids_from_results(self):
request = DummyRequest()
context = RouteFactory(request)
request.registry.permission.get_accessible_objects.return_value = {
"/obj/1": ["read", "write"],
"/obj/3": ["obj:create"],
}
context.fetch_shared_objects("read", ["userid"], None)
self.assertEqual(sorted(context.shared_ids), ["1", "3"])
def test_send_alert_code_can_be_specified(self):
request = DummyRequest()
request.registry.settings["project_docs"] = "docs_url"
send_alert(request, "Message", code="hard-eol")
self.verify_alert_header(request, {
"code": "hard-eol",
"message": "Message",
"url": "docs_url"
})
def _build_request(self):
request = DummyRequest()
request.bound_data = {}
request.registry.cache = self.backend
settings = DEFAULT_SETTINGS.copy()
settings['userid_hmac_secret'] = '1234'
settings['facebook.cache_ttl_seconds'] = '0.01'
request.registry.settings = settings
request.headers['Authorization'] = 'Bearer foo'
return request
def _build_request(self):
request = DummyRequest()
request.bound_data = {}
request.registry.cache = self.backend
settings = DEFAULT_SETTINGS.copy()
settings['fxa-oauth.cache_ttl_seconds'] = '0.01'
settings['fxa-oauth.required_scope'] = 'mandatory profile'
request.registry.settings = settings
request.headers['Authorization'] = 'Bearer foo'
return request
def _build_request(self):
request = DummyRequest()
request.bound_data = {}
request.registry.cache = self.backend
settings = {**DEFAULT_SETTINGS}
settings['portier.cache_ttl_seconds'] = '0.01'
settings['userid_hmac_secret'] = self.user_hmac_secret
request.registry.settings = settings
request.headers['Authorization'] = 'Portier %s' % self.token
return request
def setUp(self):
super().setUp()
patch = mock.patch("warnings.warn")
self.mocked_warnings = patch.start()
self.addCleanup(patch.stop)
req = DummyRequest()
req.validated = {"body": {}, "header": {}, "querystring": {}}
req.registry.storage.get_all.return_value = ([], 0)
self.resource = UserResource(request=req)
def test_kcl_drops_events_with_no_matching_records(match_buckets_a_resource):
client = mock.Mock()
listener = KintoChangesListener(client, 'broadcaster', [], [], match_buckets_a_resource)
single_record = [
{'new': changes_record('b', 'c')},
]
request = DummyRequest()
event = events.ResourceChanged(PAYLOAD, single_record, request)
listener(event)
assert not client.send_version.called
def test_http_put_sets_current_object_attribute(self):
with mock.patch("kinto.core.utils.current_service") as current_service:
# Patch current service.
resource = mock.MagicMock()
resource.object_id = 1
resource.model.get_object.return_value = mock.sentinel.object
current_service().resource.return_value = resource
# Do the actual call.
request = DummyRequest(method="put")
context = RouteFactory(request)
self.assertEqual(context.current_object, mock.sentinel.object)
def test_http_put_sets_current_record_attribute(self):
with mock.patch('kinto.core.utils.current_service') as current_service:
# Patch current service.
resource = mock.MagicMock()
resource.record_id = 1
resource.model.get_record.return_value = mock.sentinel.record
current_service().resource.return_value = resource
# Do the actual call.
request = DummyRequest(method='put')
context = RouteFactory(request)
self.assertEquals(context.current_record, mock.sentinel.record)
def test_kcl_ignores_missing_new(match_buckets_a_resource):
client = mock.Mock()
listener = KintoChangesListener(client, 'broadcaster', [], [], match_buckets_a_resource)
single_record = [
{'old': changes_record('a', 'c')},
]
request = DummyRequest()
event = events.ResourceChanged(PAYLOAD, single_record, request)
listener(event)
assert not client.send_version.called
def test_kcl_posts_on_matching_records(match_buckets_a_resource):
client = mock.Mock()
listener = KintoChangesListener(client, 'broadcaster', [], [],
match_buckets_a_resource)
single_record = [
{'new': changes_record('a', 'c')},
]
request = DummyRequest()
event = events.ResourceChanged(PAYLOAD, single_record, request)
listener(event)
client.send_version.assert_called_with('broadcaster', 'monitor_changes', '"123"')
def test_kcl_can_fail_to_match_in_collections(match_collection_z1_resource):
client = mock.Mock()
listener = KintoChangesListener(client, 'broadcaster', [], [],
match_collection_z1_resource)
one_record = [
{'new': changes_record('z', 'z2')},
]
request = DummyRequest()
event = events.ResourceChanged(PAYLOAD, one_record, request)
listener(event)
assert not client.send_version.called
def test_ping_leaves_no_tombstone(self):
request = DummyRequest()
request.headers['Authorization'] = 'Basic bWF0OjI='
ping = heartbeat(self.storage)
with mock.patch('kinto.core.storage.random.SystemRandom.random', return_value=0.7):
ping(request)
with mock.patch('kinto.core.storage.random.SystemRandom.random', return_value=0.5):
ping(request)
records, count = self.storage.get_all(parent_id='__heartbeat__',
collection_id='__heartbeat__',
include_deleted=True)
self.assertEqual(len(records), 0)
def test_user_validation_listener(self):
request = DummyRequest()
old_inactive = {"id": "alice", "password": "******", "validated": False}
old_active = {"id": "alice", "password": "******", "validated": True}
new_inactive = {"id": "alice", "password": "******", "validated": False}
new_active = {"id": "alice", "password": "******", "validated": True}
with mock.patch("kinto.plugins.accounts.mails.Emailer.send_mail"
) as mocked_send_mail:
# No email sent if account validation is not enabled.
event = ResourceChanged(
{"action": ACTIONS.UPDATE.value},
[{
"old": old_inactive,
"new": new_inactive
}],
request,
)
on_account_activated(event)
mocked_send_mail.assert_not_called()
# No email sent if the old account was already active.
request.registry.settings["account_validation"] = True
event = ResourceChanged({"action": ACTIONS.UPDATE.value},
[{
"old": old_active,
"new": new_active
}], request)
request.registry.cache.get = mock.MagicMock(return_value=None)
on_account_activated(event)
mocked_send_mail.assert_not_called()
# No email sent if the new account is still inactive.
event = ResourceChanged(
{"action": ACTIONS.UPDATE.value},
[{
"old": old_inactive,
"new": new_inactive
}],
request,
)
request.registry.cache.get = mock.MagicMock(return_value=None)
on_account_activated(event)
mocked_send_mail.assert_not_called()
# Email sent if there is an activation key in the cache.
event = ResourceChanged(
{"action": ACTIONS.UPDATE.value},
[{
"old": old_inactive,
"new": new_active
}],
request,
)
on_account_activated(event)
mocked_send_mail.assert_called_once()
def setUp(self):
super().setUp()
patch = mock.patch("warnings.warn")
self.mocked_warnings = patch.start()
self.addCleanup(patch.stop)
req = DummyRequest()
req.validated = {"body": {}, "header": {}, "querystring": {}}
req.registry.storage.list_all.return_value = []
req.registry.storage.delete_all.return_value = []
req.registry.storage.create.return_value = {"id": "abc", "last_modified": 123}
self.resource = Resource(context=mock.MagicMock(), request=req)
