def test_create_withuser(self):
"""Test access request creation with user."""
from zenodo_accessrequests.models import AccessRequest, \
RequestStatus
from zenodo_accessrequests.signals import \
request_created, request_confirmed
with request_created.connected_to(self.get_receiver('created')):
with request_confirmed.connected_to(
self.get_receiver('confirmed')):
r = AccessRequest.create(
recid=1,
receiver=self.receiver,
sender_full_name="Another Name",
sender_email="*****@*****.**",
sender=self.sender,
justification="Bla bla bla",
)
self.assertEqual(r.status, RequestStatus.PENDING)
self.assertEqual(r.sender_user_id, self.sender.get_id())
self.assertIsNotNone(r.created)
self.assertIsNotNone(r.modified)
self.assertEqual(r.message, u'')
self.assertEqual(r.sender_full_name, u'Another Name')
self.assertEqual(r.sender_email, u'*****@*****.**')
self.assertIsNone(self.called['created'])
self.assertIsNotNone(self.called['confirmed'])
def test_create_withuser(app, db, users, record_example):
"""Test access request creation with user."""
mock_request_created = Mock()
mock_request_confirmed = Mock()
pid_value, record = record_example
with app.test_request_context():
with request_created.connected_to(mock_request_created):
with request_confirmed.connected_to(mock_request_confirmed):
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
sender = datastore.get_user(users['sender']['id'])
r = AccessRequest.create(
recid=pid_value,
receiver=receiver,
sender_full_name="Another Name",
sender_email="*****@*****.**",
sender=sender,
justification="Bla bla bla",
)
assert r.status == RequestStatus.PENDING
assert r.sender_user_id == sender.id
assert r.created is not None
assert r.modified is not None
assert r.message == u''
assert r.sender_full_name == u'Another Name'
assert r.sender_email == u'*****@*****.**'
assert not mock_request_created.called
assert mock_request_confirmed.called
def test_create_nouser(self):
"""Test access request creation without user."""
from zenodo_accessrequests.models import AccessRequest, \
RequestStatus
from zenodo_accessrequests.signals import \
request_created, request_confirmed
with request_created.connected_to(self.get_receiver('created')):
with request_confirmed.connected_to(
self.get_receiver('confirmed')):
r = AccessRequest.create(
recid=1,
receiver=self.receiver,
sender_full_name="John Smith",
sender_email="*****@*****.**",
justification="Bla bla bla",
)
self.assertEqual(r.status, RequestStatus.EMAIL_VALIDATION)
self.assertIsNone(r.sender_user_id)
self.assertIsNotNone(r.created)
self.assertIsNotNone(r.modified)
self.assertEqual(r.message, u'')
self.assertIsNotNone(self.called['created'])
self.assertIsNone(self.called['confirmed'])
def test_create_withuser(app, db, users, record_example):
"""Test access request creation with user."""
mock_request_created = Mock()
mock_request_confirmed = Mock()
pid_value, record = record_example
with app.test_request_context():
with request_created.connected_to(mock_request_created):
with request_confirmed.connected_to(mock_request_confirmed):
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
sender = datastore.get_user(users['sender']['id'])
r = AccessRequest.create(
recid=pid_value,
receiver=receiver,
sender_full_name="Another Name",
sender_email="*****@*****.**",
sender=sender,
justification="Bla bla bla",
)
assert r.status == RequestStatus.PENDING
assert r.sender_user_id == sender.id
assert r.created is not None
assert r.modified is not None
assert r.message == u''
assert r.sender_full_name == u'Another Name'
assert r.sender_email == u'*****@*****.**'
assert not mock_request_created.called
assert mock_request_confirmed.called
def test_create_nouser(app, db, users, record_example):
"""Test access request creation without user."""
mock_request_created = Mock()
mock_request_confirmed = Mock()
pid_value, record = record_example
with app.test_request_context():
with request_created.connected_to(mock_request_created):
with request_confirmed.connected_to(mock_request_confirmed):
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
r = AccessRequest.create(
recid=pid_value,
receiver=receiver,
sender_full_name="John Smith",
sender_email="*****@*****.**",
justification="Bla bla bla",
)
assert r.status == RequestStatus.EMAIL_VALIDATION
assert r.sender_user_id is None
assert r.created is not None
assert r.modified is not None
assert r.message == u''
assert mock_request_created.called
assert not mock_request_confirmed.called
def test_create_nouser(app, db, users, record_example):
"""Test access request creation without user."""
mock_request_created = Mock()
mock_request_confirmed = Mock()
pid_value, record = record_example
with app.test_request_context():
with request_created.connected_to(mock_request_created):
with request_confirmed.connected_to(mock_request_confirmed):
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
r = AccessRequest.create(
recid=pid_value,
receiver=receiver,
sender_full_name="John Smith",
sender_email="*****@*****.**",
justification="Bla bla bla",
)
assert r.status == RequestStatus.EMAIL_VALIDATION
assert r.sender_user_id is None
assert r.created is not None
assert r.modified is not None
assert r.message == u''
assert mock_request_created.called
assert not mock_request_confirmed.called
def test_create_withuser(self):
"""Test access request creation with user."""
from zenodo_accessrequests.models import AccessRequest, \
RequestStatus
from zenodo_accessrequests.signals import \
request_created, request_confirmed
with request_created.connected_to(self.get_receiver('created')):
with request_confirmed.connected_to(
self.get_receiver('confirmed')):
r = AccessRequest.create(
recid=1,
receiver=self.receiver,
sender_full_name="Another Name",
sender_email="*****@*****.**",
sender=self.sender,
justification="Bla bla bla",
)
self.assertEqual(r.status, RequestStatus.PENDING)
self.assertEqual(r.sender_user_id, self.sender.get_id())
self.assertIsNotNone(r.created)
self.assertIsNotNone(r.modified)
self.assertEqual(r.message, u'')
self.assertEqual(r.sender_full_name, u'Another Name')
self.assertEqual(r.sender_email, u'*****@*****.**')
self.assertIsNone(self.called['created'])
self.assertIsNotNone(self.called['confirmed'])
def test_create_nouser(self):
"""Test access request creation without user."""
from zenodo_accessrequests.models import AccessRequest, \
RequestStatus
from zenodo_accessrequests.signals import \
request_created, request_confirmed
with request_created.connected_to(self.get_receiver('created')):
with request_confirmed.connected_to(
self.get_receiver('confirmed')):
r = AccessRequest.create(
recid=1,
receiver=self.receiver,
sender_full_name="John Smith",
sender_email="*****@*****.**",
justification="Bla bla bla",
)
self.assertEqual(r.status, RequestStatus.EMAIL_VALIDATION)
self.assertIsNone(r.sender_user_id)
self.assertIsNotNone(r.created)
self.assertIsNotNone(r.modified)
self.assertEqual(r.message, u'')
self.assertIsNotNone(self.called['created'])
self.assertIsNone(self.called['confirmed'])
def create_access_request(pid_value, users, confirmed):
"""Access Request."""
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
sender = datastore.get_user(users['sender']['id'])
return AccessRequest.create(
recid=pid_value,
receiver=receiver,
sender_full_name="Another Name",
sender_email="*****@*****.**",
sender=sender if confirmed else None,
justification="Bla bla bla",
)
def create_access_request(pid_value, users, confirmed):
"""Access Request."""
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
sender = datastore.get_user(users['sender']['id'])
return AccessRequest.create(
recid=pid_value,
receiver=receiver,
sender_full_name="Another Name",
sender_email="*****@*****.**",
sender=sender if confirmed else None,
justification="Bla bla bla",
)
def test_query_by_receiver(self):
"""Test query by receiver."""
from zenodo_accessrequests.models import AccessRequest
self.assertEqual(
AccessRequest.query_by_receiver(self.receiver).count(), 0)
self.assertEqual(
AccessRequest.query_by_receiver(self.sender).count(), 0)
# Create an accesrequest
r = self.get_request(confirmed=False)
self.assertEqual(
AccessRequest.query_by_receiver(self.receiver).count(), 1)
self.assertEqual(
AccessRequest.query_by_receiver(self.sender).count(), 0)
self.assertIsNotNone(AccessRequest.get_by_receiver(
r.id, self.receiver))
self.assertIsNone(AccessRequest.get_by_receiver(r.id, self.sender))
def test_query_by_receiver(app, db, users, record_example):
"""Test query by receiver."""
pid_value, record = record_example
with app.test_request_context():
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
sender = datastore.get_user(users['sender']['id'])
assert AccessRequest.query_by_receiver(receiver).count() == 0
assert AccessRequest.query_by_receiver(sender).count() == 0
# Create an accesrequest
r = create_access_request(pid_value=pid_value, users=users,
confirmed=False)
assert AccessRequest.query_by_receiver(receiver).count() == 1
assert AccessRequest.query_by_receiver(sender).count() == 0
assert AccessRequest.get_by_receiver(r.id, receiver) is not None
assert AccessRequest.get_by_receiver(r.id, sender) is None
def test_query_by_receiver(app, db, users, record_example):
"""Test query by receiver."""
pid_value, record = record_example
with app.test_request_context():
datastore = current_app.extensions['security'].datastore
receiver = datastore.get_user(users['receiver']['id'])
sender = datastore.get_user(users['sender']['id'])
assert AccessRequest.query_by_receiver(receiver).count() == 0
assert AccessRequest.query_by_receiver(sender).count() == 0
# Create an accesrequest
r = create_access_request(pid_value=pid_value,
users=users,
confirmed=False)
assert AccessRequest.query_by_receiver(receiver).count() == 1
assert AccessRequest.query_by_receiver(sender).count() == 0
assert AccessRequest.get_by_receiver(r.id, receiver) is not None
assert AccessRequest.get_by_receiver(r.id, sender) is None
def test_query_by_receiver(self):
"""Test query by receiver."""
from zenodo_accessrequests.models import AccessRequest
self.assertEqual(
AccessRequest.query_by_receiver(self.receiver).count(),
0)
self.assertEqual(
AccessRequest.query_by_receiver(self.sender).count(),
0)
# Create an accesrequest
r = self.get_request(confirmed=False)
self.assertEqual(
AccessRequest.query_by_receiver(self.receiver).count(),
1)
self.assertEqual(
AccessRequest.query_by_receiver(self.sender).count(),
0)
self.assertIsNotNone(AccessRequest.get_by_receiver(
r.id, self.receiver))
self.assertIsNone(AccessRequest.get_by_receiver(
r.id, self.sender))
