def test_orcid_login_callback_researcher_flow(patch, patch2, request_ctx):
"""Test login from orcid callback function for researcher and display profile."""
org = Organisation.create(name="THE ORGANISATION",
tuakiri_name="THE ORGANISATION",
confirmed=True,
orcid_client_id="CLIENT ID",
orcid_secret="Client Secret",
city="CITY",
country="COUNTRY",
disambiguated_id="ID",
disambiguation_source="SOURCE",
is_email_sent=True)
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="123",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org, is_admin=False)
token = utils.generate_confirmation_token(email=u.email, org=org.name)
UserInvitation.create(email=u.email,
token=token,
affiliations=Affiliation.EMP)
OrcidToken.create(user=u,
org=org,
scope='/read-limited,/activities/update')
with request_ctx():
request.args = {"invitation_token": token, "state": "xyz"}
session['oauth_state'] = "xyz"
resp = authcontroller.orcid_login_callback(request)
assert resp.status_code == 302
# display profile
assert resp.location.startswith("/profile")
def test_process_other_id_records(app, mocker):
"""Test create or update researcher other id."""
mocker.patch("orcid_hub.utils.send_email", send_mail_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_external_identifierv3",
create_or_update_fund_mock)
mocker.patch("orcid_hub.orcid_client.MemberAPIV3.get_record",
return_value=get_profile())
org = app.data["org"]
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="12344",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=TaskType.OTHER_ID)
OtherIdRecord.create(task=t,
type="grant_number",
value="xyz",
url="https://xyz.com",
relationship="SELF",
is_active=True,
status="email sent",
first_name="Test",
last_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
display_index=1)
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scopes="/read-limited,/person/update",
access_token="Test_token")
utils.process_other_id_records()
record = OtherIdRecord.get(email="*****@*****.**")
assert 12399 == record.put_code
assert "12344" == record.orcid
def test_new_invitation_token(app):
"""Test if the tokens are realy unique."""
random.seed(42)
token0 = ''.join(
random.choice(string.ascii_letters + string.digits) for _ in range(5))
random.seed(42)
token = utils.new_invitation_token()
assert token == token0
org, user, admin = [app.data[n] for n in ["org", "user", "admin"]]
UserInvitation.create(org=org, invitee=user, inviter=admin, token=token)
random.seed(42)
token2 = utils.new_invitation_token()
assert token2 != token
def test_orcid_login(client):
"""Test login from orcid."""
org = Organisation.get(name="THE ORGANISATION")
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.TECHNICAL,
orcid="123",
confirmed=True,
organisation=org)
user_org = UserOrg.create(user=u, org=org, is_admin=True)
resp = client.get("/orcid/login/NOT-EXISTTING", follow_redirects=True)
assert resp.status_code == 200
assert b"Failed to login via ORCID using token NOT-EXISTTING" in resp.data
token = "TOKEN-1234567"
ui = UserInvitation.create(org=org, invitee=u, email=u.email, token=token)
resp = client.get(f"/orcid/login/{token}")
assert resp.status_code == 200
orcid_authorize = OrcidAuthorizeCall.get(method="GET")
assert "&email=test123_test_orcid_login%40test.test.net" in orcid_authorize.url
ui.created_at -= timedelta(days=100)
ui.save()
resp = client.get(f"/orcid/login/{token}")
assert resp.status_code == 302
url = urlparse(resp.location)
assert url.path == '/'
# Testing the expired token flow for researcher
user_org.is_admin = False
user_org.save()
resp = client.get(f"/orcid/login/{token}")
assert resp.status_code == 302
url = urlparse(resp.location)
assert url.path == '/'
def test_test_database(models):
"""Test of the consitency of the test database."""
assert Organisation.select().count() == 10
assert User.select().count() == 63
assert OrcidToken.select().count() == 60
assert AffiliationRecord.select().count() == 10
assert FundingRecord.select().count() == 10
assert FundingContributor.select().count() == 10
assert FundingInvitee.select().count() == 10
assert ExternalId.select().count() == 10
assert WorkRecord.select().count() == 10
assert WorkContributor.select().count() == 10
assert WorkExternalId.select().count() == 10
assert WorkInvitee.select().count() == 10
assert PeerReviewRecord.select().count() == 10
assert PeerReviewExternalId.select().count() == 10
assert PeerReviewInvitee.select().count() == 10
assert ResearcherUrlRecord.select().count() == 10
assert OtherNameRecord.select().count() == 10
assert KeywordRecord.select().count() == 10
assert Task.select().count() == 30
assert UserOrgAffiliation.select().count() == 30
assert User.get(id=43).admin_for.count() == 10
assert User.get(id=1).admin_for.count() == 0
assert User.get(id=42).admin_for.count() > 0
assert User.get(id=2).organisations.count() > 0
assert Organisation.get(id=1).admins.count() == 1
assert Organisation.get(id=5).users.count() > 0
assert Organisation.get(id=5).admins.count() > 0
assert User.select().where(User.orcid == User.get(
email="*****@*****.**").orcid).count() == 3
assert len(User.get(email="*****@*****.**").org_links) == 3
user = User.get(email="*****@*****.**")
available_organisations = user.available_organisations
assert available_organisations.count() == 10
admin = User.create(email="*****@*****.**", organisation=user.organisation, confirmed=True,
first_name="TEST", last_name="ADMIN", roles=Role.ADMIN)
ui = UserInvitation.create(email=user.email, invitee=user, inviter=admin, token="TOKEN-123")
admin.delete_instance()
ui = UserInvitation.get(ui.id)
assert ui.inviter_id is None
user.delete_instance()
assert not UserInvitation.select().where(UserInvitation.id == ui.id).exists()
org = Organisation.select().limit(1).first()
user = User.select().limit(1).first()
ot = OrcidToken.create(user=user, org=org, scope="S1,S2,S3")
assert len(ot.scopes) == 3
ot.scopes = ["A", "B", "C", "D"]
assert ot.scope == "A,B,C,D"
def test_create_or_update_affiliation(patch, test_db, request_ctx):
"""Test create or update affiliation."""
org = Organisation.create(name="THE ORGANISATION",
tuakiri_name="THE ORGANISATION",
confirmed=True,
orcid_client_id="APP-5ZVH4JRQ0C27RVH5",
orcid_secret="Client Secret",
city="CITY",
country="COUNTRY",
disambiguation_org_id="ID",
disambiguation_org_source="SOURCE")
u = User.create(email="*****@*****.**",
name="TEST USER",
username="******",
roles=Role.RESEARCHER,
orcid="123",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=0)
AffiliationRecord.create(is_active=True,
task=t,
external_id="Test",
first_name="Test",
last_name="Test",
email="*****@*****.**",
orcid="123112311231",
organisation="asdasd",
affiliation_type="staff",
role="Test",
department="Test",
city="Test",
state="Test",
country="Test",
disambiguated_id="Test",
disambiguation_source="Test")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scope="/read-limited,/activities/update",
access_token="Test_token")
tasks = (Task.select(
Task, AffiliationRecord, User,
UserInvitation.id.alias("invitation_id"), OrcidToken
).where(
AffiliationRecord.processed_at.is_null(), AffiliationRecord.is_active,
((User.id.is_null(False)
& User.orcid.is_null(False) & OrcidToken.id.is_null(False)) |
((User.id.is_null() | User.orcid.is_null() | OrcidToken.id.is_null())
& UserInvitation.id.is_null() &
(AffiliationRecord.status.is_null()
| AffiliationRecord.status.contains("sent").__invert__())))).join(
AffiliationRecord,
on=(Task.id == AffiliationRecord.task_id)).join(
User,
JOIN.LEFT_OUTER,
on=((User.email == AffiliationRecord.email) |
(User.orcid == AffiliationRecord.orcid))).join(
Organisation,
JOIN.LEFT_OUTER,
on=(Organisation.id == Task.org_id)).
join(UserInvitation,
JOIN.LEFT_OUTER,
on=((UserInvitation.email == AffiliationRecord.email) &
(UserInvitation.task_id == Task.id))).join(
OrcidToken,
JOIN.LEFT_OUTER,
on=((OrcidToken.user_id == User.id) &
(OrcidToken.org_id == Organisation.id) &
(OrcidToken.scope.contains("/activities/update"))
)).limit(20))
for (task_id, org_id, user), tasks_by_user in groupby(
tasks, lambda t: (
t.id,
t.org_id,
t.affiliation_record.user,
)):
utils.create_or_update_affiliations(user=user,
org_id=org_id,
records=tasks_by_user)
affiliation_record = AffiliationRecord.get(task=t)
assert 12399 == affiliation_record.put_code
assert "12344" == affiliation_record.orcid
assert "Employment record was updated" in affiliation_record.status
def test_create_or_update_peer_review(email_patch, patch, test_db,
request_ctx):
"""Test create or update peer review."""
org = Organisation.create(name="THE ORGANISATION",
tuakiri_name="THE ORGANISATION",
confirmed=True,
orcid_client_id="APP-5ZVH4JRQ0C27RVH5",
orcid_secret="Client Secret",
city="CITY",
country="COUNTRY",
disambiguation_org_id="ID",
disambiguation_org_source="SOURCE")
u = User.create(email="*****@*****.**",
name="TEST USER",
username="******",
roles=Role.RESEARCHER,
orcid="12344",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(id=12,
org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=3)
pr = PeerReviewRecord.create(task=t,
review_group_id="issn:12131",
reviewer_role="reviewer",
review_url="xyz",
review_type="REVIEW",
subject_external_id_type="doi",
subject_external_id_value="1212",
subject_external_id_url="url/SELF",
subject_external_id_relationship="SELF",
subject_container_name="Journal title",
subject_type="JOURNAL_ARTICLE",
subject_name_title="name",
subject_name_subtitle="subtitle",
subject_name_translated_title_lang_code="en",
subject_name_translated_title="sdsd",
subject_url="url",
convening_org_name="THE ORGANISATION",
convening_org_city="auckland",
convening_org_region="auckland",
convening_org_country="nz",
convening_org_disambiguated_identifier="123",
convening_org_disambiguation_source="1212",
is_active=True)
PeerReviewInvitee.create(peer_review_record=pr,
first_name="Test",
email="*****@*****.**",
orcid="12344",
visibility="PUBLIC")
PeerReviewExternalId.create(peer_review_record=pr,
type="Test_type",
value="122334_different",
url="Test",
relationship="SELF")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scope="/read-limited,/activities/update",
access_token="Test_token")
utils.process_peer_review_records()
peer_review_invitees = PeerReviewInvitee.get(orcid=12344)
assert 12399 == peer_review_invitees.put_code
assert "12344" == peer_review_invitees.orcid
def test_create_or_update_work(email_patch, patch, test_db, request_ctx):
"""Test create or update work."""
org = Organisation.create(name="THE ORGANISATION",
tuakiri_name="THE ORGANISATION",
confirmed=True,
orcid_client_id="APP-5ZVH4JRQ0C27RVH5",
orcid_secret="Client Secret",
city="CITY",
country="COUNTRY",
disambiguation_org_id="ID",
disambiguation_org_source="SOURCE")
u = User.create(email="*****@*****.**",
name="TEST USER",
username="******",
roles=Role.RESEARCHER,
orcid="12344",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=2)
wr = WorkRecord.create(task=t,
title="Test titile",
sub_title="Test titile",
translated_title="Test title",
translated_title_language_code="Test",
journal_title="Test titile",
short_description="Test desc",
citation_type="Test",
citation_value="Test",
type="BOOK_CHAPTER",
url="Test org",
language_code="en",
country="Test",
org_name="Test_orgname",
city="Test city",
region="Test",
is_active=True)
WorkInvitees.create(work_record=wr,
first_name="Test",
email="*****@*****.**",
orcid="12344",
visibility="PUBLIC")
WorkExternalId.create(work_record=wr,
type="Test_type",
value="Test_value",
url="Test",
relationship="SELF")
WorkContributor.create(work_record=wr,
contributor_sequence="1",
orcid="1213",
role="LEAD",
name="xyz",
email="*****@*****.**")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scope="/read-limited,/activities/update",
access_token="Test_token")
utils.process_work_records()
work_invitees = WorkInvitees.get(orcid=12344)
assert 12399 == work_invitees.put_code
assert "12344" == work_invitees.orcid
def test_create_or_update_funding(email_patch, patch, test_db, request_ctx):
"""Test create or update funding."""
org = Organisation.create(name="THE ORGANISATION",
tuakiri_name="THE ORGANISATION",
confirmed=True,
orcid_client_id="APP-5ZVH4JRQ0C27RVH5",
orcid_secret="Client Secret",
city="CITY",
country="COUNTRY",
disambiguation_org_id="ID",
disambiguation_org_source="SOURCE")
u = User.create(email="*****@*****.**",
name="TEST USER",
username="******",
roles=Role.RESEARCHER,
orcid="123",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=1)
fr = FundingRecord.create(task=t,
title="Test titile",
translated_title="Test title",
translated_title_language_code="Test",
type="GRANT",
organization_defined_type="Test org",
short_description="Test desc",
amount="1000",
currency="USD",
org_name="Test_orgname",
city="Test city",
region="Test",
country="Test",
disambiguated_org_identifier="Test_dis",
disambiguation_source="Test_source",
is_active=True)
FundingInvitees.create(funding_record=fr,
first_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
orcid="123")
ExternalId.create(funding_record=fr,
type="Test_type",
value="Test_value",
url="Test",
relationship="SELF")
FundingContributor.create(funding_record=fr,
orcid="1213",
role="LEAD",
name="Contributor",
email="*****@*****.**")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scope="/read-limited,/activities/update",
access_token="Test_token")
utils.process_funding_records()
funding_invitees = FundingInvitees.get(orcid=12344)
assert 12399 == funding_invitees.put_code
assert "12344" == funding_invitees.orcid
def test_orcid_login_callback_researcher_flow(client, mocker):
"""Test login from orcid callback function for researcher and display profile."""
fetch_token = mocker.patch("orcid_hub.OAuth2Session.fetch_token",
side_effect=fetch_token_mock)
mocker.patch(
"orcid_hub.orcid_client.MemberAPI.create_or_update_affiliation",
side_effect=affiliation_mock)
org = Organisation.create(
name="THE ORGANISATION:test_orcid_login_callback_researcher_flow",
tuakiri_name=
"THE ORGANISATION:test_orcid_login_callback_researcher_flow",
confirmed=True,
orcid_client_id="CLIENT ID",
orcid_secret="Client Secret",
city="CITY",
country="COUNTRY",
disambiguated_id="ID",
disambiguation_source="RINGGOLD",
is_email_sent=True)
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="123",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org, is_admin=False)
token = utils.new_invitation_token()
UserInvitation.create(email=u.email,
token=token,
affiliations=Affiliation.EMP,
org=org,
invitee=u)
resp = client.get(f"/orcid/login/{token}")
assert resp.status_code == 200
assert token.encode() in resp.data
state = session['oauth_state']
resp = client.get(f"/auth/?state={state}&login=1")
assert resp.status_code == 302
assert resp.location.endswith("/link")
fetch_token.assert_called_once()
resp = client.get(f"/auth/?invitation_token={token}&login=1")
assert resp.status_code == 302
assert urlparse(resp.location).path == "/"
fetch_token.assert_called_once()
resp = client.get(f"/auth/?invitation_token={token}&login=1",
follow_redirects=True)
assert b"Danger" in resp.data
assert b"Something went wrong, Please retry giving permissions " in resp.data
fetch_token.reset_mock()
resp = client.get(f"/auth/?invitation_token={token}&state={state}",
follow_redirects=True)
assert b"Warning" in resp.data
assert b"The ORCID Hub was not able to automatically write an affiliation" in resp.data
OrcidToken.delete().where(OrcidToken.user == u,
OrcidToken.org == org).execute()
fetch_token.reset_mock()
resp = client.get(f"/auth/?invitation_token={token}&state={state}&login=1")
assert resp.status_code == 302
assert resp.location.endswith("/profile")
fetch_token.assert_called_once()
assert OrcidToken.select().where(OrcidToken.user == u).count() == 1
resp = client.get(f"/orcid/login/{token}", follow_redirects=True)
assert b"You have already given permission" in resp.data
def test_create_or_update_affiliation(app, mocker):
"""Test create or update affiliation."""
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.update_employmentv3",
return_value=Mock(status=201, headers={'Location': '12344/XYZ/12399'}))
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_employmentv3",
return_value=Mock(status=201, headers={'Location': '12344/XYZ/12399'}))
send_email = mocker.patch("orcid_hub.utils.send_email")
capture_event = mocker.patch(
"sentry_sdk.transport.HttpTransport.capture_event")
org = app.data["org"]
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="123",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=TaskType.AFFILIATION)
OrcidToken.create(user=u,
org=org,
scopes="/read-limited,/activities/update",
access_token="Test_token")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
u = User.create(email="*****@*****.**",
name="TEST USER 2",
roles=Role.RESEARCHER,
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
AffiliationRecord.create(is_active=True,
task=t,
local_id="Test",
first_name="Test",
last_name="Test",
email="*****@*****.**",
orcid="123112311231",
organisation="asdasd",
affiliation_type="staff",
role="Test",
department="Test",
city="Test",
state="Test",
country="NZ",
disambiguated_id="Test",
disambiguation_source="Test")
AffiliationRecord.create(is_active=True,
task=t,
local_id="Test",
first_name="Test",
last_name="Test",
email="*****@*****.**",
orcid="123112311231",
organisation=org.name,
affiliation_type="staff",
role="Test",
department="Test",
city="Test",
state="Test",
country="NZ")
AffiliationRecord.create(is_active=True,
task=t,
local_id="Test",
first_name="Test",
last_name="Test",
email="*****@*****.**",
orcid="123112311231",
organisation="ANOTHER ORG",
affiliation_type="staff",
role="Test",
department="Test",
city="Test",
state="Test",
country="NZ",
visibility="PUBLIC")
AffiliationRecord.create(is_active=True,
task=t,
local_id="Test#2",
first_name="Test2",
last_name="Test2",
email="*****@*****.**",
organisation=org.name,
affiliation_type="staff")
tasks = (Task.select(
Task, AffiliationRecord, User,
UserInvitation.id.alias("invitation_id"), OrcidToken).join(
AffiliationRecord,
on=(Task.id == AffiliationRecord.task_id).alias("record")).join(
User,
JOIN.LEFT_OUTER,
on=((User.email == AffiliationRecord.email)
| (User.orcid == AffiliationRecord.orcid))).join(
Organisation,
JOIN.LEFT_OUTER,
on=(Organisation.id == Task.org_id)).join(
UserInvitation,
JOIN.LEFT_OUTER,
on=((UserInvitation.email
== AffiliationRecord.email)
& (UserInvitation.task_id == Task.id))).
join(OrcidToken,
JOIN.LEFT_OUTER,
on=((OrcidToken.user_id == User.id)
& (OrcidToken.org_id == Organisation.id)
& (OrcidToken.scopes.contains("/activities/update")))))
app.config["SERVER_NAME"] = "orcidhub"
for (task_id, org_id, user), tasks_by_user in groupby(
tasks, lambda t: (
t.id,
t.org_id,
t.record.user,
)):
with patch("orcid_hub.orcid_client.MemberAPIV3.get_record",
return_value=get_profile()
if user.orcid else None) as get_record:
utils.create_or_update_affiliations(user=user,
org_id=org_id,
records=tasks_by_user)
get_record.assert_any_call()
affiliation_record = AffiliationRecord.select().order_by(
AffiliationRecord.id).limit(1).first()
assert 12399 == affiliation_record.put_code
assert "12344" == affiliation_record.orcid
assert ("Employment record was updated" in affiliation_record.status
or "Employment record was created" in affiliation_record.status)
capture_event.assert_called()
send_email.assert_called_once()
def test_create_or_update_property_record(app, mocker):
"""Test create or update researcher keyword, researcher url, other name and country"""
mocker.patch("orcid_hub.utils.send_email", send_mail_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_keywordv3",
create_or_update_fund_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_researcher_urlv3",
create_or_update_fund_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_other_namev3",
create_or_update_fund_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_addressv3",
create_or_update_fund_mock)
mocker.patch("orcid_hub.orcid_client.MemberAPIV3.get_record",
return_value=get_profile())
org = app.data["org"]
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="12344",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
OrcidToken.create(user=u,
org=org,
scopes="/read-limited,/person/update",
access_token="Test_token")
t = Task.create(id=12,
org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=TaskType.PROPERTY)
PropertyRecord.create(task=t,
type="KEYWORD",
is_active=True,
status="email sent",
first_name="Test",
last_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
value="dummy name",
display_index=1)
PropertyRecord.create(task=t,
type="COUNTRY",
is_active=True,
status="email sent",
first_name="Test",
last_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
value="IN",
display_index=1)
PropertyRecord.create(task=t,
type="URL",
is_active=True,
status="email sent",
first_name="Test",
last_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
name="url name",
value="https://www.xyz.com",
display_index=1)
PropertyRecord.create(task=t,
type="NAME",
is_active=True,
status="email sent",
first_name="Test",
last_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
value="dummy name",
display_index=1)
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
utils.process_property_records()
keyword_record = PropertyRecord.get(email="*****@*****.**",
type="KEYWORD")
assert 12399 == keyword_record.put_code
assert "12344" == keyword_record.orcid
address_record = PropertyRecord.get(email="*****@*****.**",
type="COUNTRY")
assert 12399 == address_record.put_code
assert "12344" == address_record.orcid
url_record = PropertyRecord.get(email="*****@*****.**",
type="URL")
assert 12399 == url_record.put_code
assert "12344" == url_record.orcid
other_name_record = PropertyRecord.get(email="*****@*****.**",
type="NAME")
assert 12399 == other_name_record.put_code
assert "12344" == other_name_record.orcid
def test_create_or_update_peer_review(app, mocker):
"""Test create or update peer review."""
mocker.patch("orcid_hub.utils.send_email", send_mail_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_peer_reviewv3",
create_or_update_fund_mock)
org = app.data["org"]
mocker.patch("orcid_hub.orcid_client.MemberAPIV3.get_record",
return_value=get_profile(org=org))
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="12344",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(id=12,
org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=TaskType.PEER_REVIEW)
pr = PeerReviewRecord.create(
task=t,
review_group_id="issn:12131",
reviewer_role="reviewer",
review_url="xyz",
review_type="REVIEW",
subject_external_id_type="doi",
subject_external_id_value="1212",
subject_external_id_url="url/SELF",
subject_external_id_relationship="SELF",
subject_container_name="Journal title",
subject_type="JOURNAL_ARTICLE",
subject_name_title="name",
subject_name_subtitle="subtitle",
review_completion_date=PartialDate.create("2003-07-14"),
subject_name_translated_title_lang_code="en",
subject_name_translated_title="sdsd",
subject_url="url",
convening_org_name="THE ORGANISATION",
convening_org_city="auckland",
convening_org_region="auckland",
convening_org_country="NZ",
convening_org_disambiguated_identifier="123",
convening_org_disambiguation_source="1212",
is_active=True)
PeerReviewInvitee.create(record=pr,
first_name="Test",
email="*****@*****.**",
orcid="12344",
visibility="PUBLIC")
PeerReviewExternalId.create(record=pr,
type="Test_type",
value="122334_different",
url="Test",
relationship="SELF")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scopes="/read-limited,/activities/update",
access_token="Test_token")
utils.process_peer_review_records()
peer_review_invitees = PeerReviewInvitee.get(orcid=12344)
assert 12399 == peer_review_invitees.put_code
assert "12344" == peer_review_invitees.orcid
def test_create_or_update_work(app, mocker):
"""Test create or update work."""
mocker.patch("orcid_hub.utils.send_email", send_mail_mock)
mocker.patch("orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_workv3",
create_or_update_fund_mock)
org = app.data["org"]
mocker.patch("orcid_hub.orcid_client.MemberAPIV3.get_record",
return_value=get_profile(org=org))
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="12344",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=TaskType.WORK)
wr = WorkRecord.create(task=t,
title="Test titile",
subtitle="Test titile",
translated_title="Test title",
translated_title_language_code="hi",
journal_title="Test titile",
short_description="Test desc",
citation_type="bibtex",
citation_value="Test",
type="BOOK_CHAPTER",
publication_date=PartialDate.create("2003-07-14"),
url="Test org",
language_code="en",
country="NZ",
org_name="Test_orgname",
city="Test city",
region="Test",
is_active=True)
WorkInvitee.create(record=wr,
first_name="Test",
email="*****@*****.**",
orcid="12344",
visibility="PUBLIC")
WorkExternalId.create(record=wr,
type="Test_type",
value="Test_value",
url="Test",
relationship="SELF")
WorkContributor.create(record=wr,
contributor_sequence="first",
orcid="1213",
role="author",
name="xyz",
email="*****@*****.**")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scopes="/read-limited,/activities/update",
access_token="Test_token")
utils.process_work_records()
invitee = WorkInvitee.get(orcid="12344")
assert 12399 == invitee.put_code
assert "12344" == invitee.orcid
def test_create_or_update_funding(app, mocker):
"""Test create or update funding."""
mocker.patch("orcid_hub.utils.send_email", send_mail_mock)
mocker.patch(
"orcid_api_v3.api.DevelopmentMemberAPIV30Api.create_fundingv3",
create_or_update_fund_mock)
org = app.data["org"]
mocker.patch("orcid_hub.orcid_client.MemberAPIV3.get_record",
return_value=get_profile(org=org))
u = User.create(email="*****@*****.**",
name="TEST USER",
roles=Role.RESEARCHER,
orcid="123",
confirmed=True,
organisation=org)
UserOrg.create(user=u, org=org)
t = Task.create(org=org,
filename="xyz.json",
created_by=u,
updated_by=u,
task_type=TaskType.FUNDING)
fr = FundingRecord.create(task=t,
title="Test titile",
translated_title="Test title",
translated_title_language_code="hi",
type="GRANT",
organization_defined_type="Test org",
short_description="Test desc",
amount="1000",
currency="USD",
org_name="Test_orgname",
city="Test city",
region="Test",
url="url",
start_date=PartialDate.create("2003-07-14"),
end_date=PartialDate.create("2004-07-14"),
country="NZ",
disambiguated_id="Test_dis",
disambiguation_source="Test_source",
is_active=True)
FundingInvitee.create(record=fr,
first_name="Test",
email="*****@*****.**",
visibility="PUBLIC",
orcid="123")
ExternalId.create(record=fr,
type="Test_type",
value="Test_value",
url="Test",
relationship="SELF")
FundingContributor.create(record=fr,
orcid="1213",
role="LEAD",
name="Contributor",
email="*****@*****.**")
UserInvitation.create(invitee=u,
inviter=u,
org=org,
task=t,
email="*****@*****.**",
token="xyztoken")
OrcidToken.create(user=u,
org=org,
scopes="/read-limited,/activities/update",
access_token="Test_token")
utils.process_funding_records()
funding_invitees = FundingInvitee.get(orcid="12344")
assert 12399 == funding_invitees.put_code
assert "12344" == funding_invitees.orcid