def test_authors_application_json_delete_without_token(inspire_app):
record = create_record("aut")
record_control_number = record["control_number"]
expected_status_code = 401
with inspire_app.test_client() as client:
response = client.delete("/authors/{}".format(record_control_number))
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_close_expired_jobs_with_notify(mock_send_job_deadline_reminder,
inspire_app, cli):
expired_record = create_record("job",
data={
"status": "open",
"deadline_date": "2019-11-01"
})
not_expired_record = create_record("job",
data={
"status": "open",
"deadline_date": "2020-11-01"
})
result = cli.invoke(["jobs", "close_expired_jobs", "--notify"])
expired_record = JobsRecord.get_record_by_pid_value(
expired_record["control_number"])
mock_send_job_deadline_reminder.assert_called_once()
mock_send_job_deadline_reminder.assert_called_with(dict(expired_record))
def test_get_record_and_schema_requires_cataloger_logged_in(inspire_app):
user = create_user()
conference = create_record("con")
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(
f"api/editor/conferences/{conference['control_number']}")
assert response.status_code == 403
def test_literature_references_with_invalid_size(inspire_app):
record = create_record("lit", data=faker.record("lit"))
headers = {"Accept": "application/json"}
with inspire_app.test_client() as client:
response = client.get(
f"/literature/{record['control_number']}/references?size=0",
headers=headers)
response_status_code = response.status_code
expected_status_code = 400
assert expected_status_code == response_status_code
def test_regression_index_literature_record_with_related_records(
inspire_app, datadir):
data = json.loads((datadir / "1503270.json").read_text())
record = create_record("lit", data=data)
response = es_search("records-hep")
result = response["hits"]["hits"][0]["_source"]
assert data["related_records"] == result["related_records"]
def test_hard_delete_literature_clears_entries_in_conference_literature_table(
inspire_app, ):
conference = create_record("con")
conference_control_number = conference["control_number"]
ref = f"http://localhost:8000/api/conferences/{conference_control_number}"
rec_data = {
"publication_info": [{
"conference_record": {
"$ref": ref
}
}],
"document_type": ["conference paper"],
}
rec = create_record("lit", rec_data)
rec.hard_delete()
assert len(conference.model.conference_documents) == 0
def test_minter_bai_respects_feature_flag(inspire_app, override_config):
with override_config(FEATURE_FLAG_ENABLE_BAI_PROVIDER=False):
record = create_record("aut")
expected_pids_len = 0
result_pids_len = PersistentIdentifier.query.filter_by(
object_uuid=record.id, pid_type="bai").count()
assert result_pids_len == expected_pids_len
def test_literature_get_records_by_pids_returns_correct_record(inspire_app):
record1 = create_record("lit")
record1_control_number = record1["control_number"]
record2 = create_record("lit")
record2_control_number = record2["control_number"]
expected_control_numbers = [record1_control_number, record2_control_number]
result = LiteratureSearch().get_records_by_pids([("lit",
record1_control_number)])
assert len(result) == 1
assert (json.loads(
result[0]._ui_display)["control_number"] == record1["control_number"])
result = LiteratureSearch().get_records_by_pids([
("lit", record1_control_number), ("lit", record2_control_number)
])
assert len(result) == len(expected_control_numbers)
for rec in result:
assert rec.to_dict()["control_number"] in expected_control_numbers
def test_jobs_application_json_get(inspire_app):
record = create_record("job")
record_control_number = record["control_number"]
expected_status_code = 200
with inspire_app.test_client() as client:
response = client.get(f"/jobs/{record_control_number}")
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_authors_search_contains_acquisition_source_for_curator(inspire_app):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = {
"$schema": "https://inspire/schemas/records/authors.json",
"_collections": ["Authors"],
"_private_notes": [{"value": "A private note"}],
"acquisition_source": {"orcid": "0000-0000-0000-0000", "email": "*****@*****.**"},
"name": {"value": "Urhan, Harun"},
"deleted": False,
}
create_record("aut", data=data)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get("/authors", headers=headers)
assert response.status_code == 200
assert "acquisition_source" in response.json["hits"]["hits"][0]["metadata"]
def test_jobs_facets(inspire_app, datadir):
data = orjson.loads((datadir / "1735925.json").read_text())
create_record("job", data=data)
expected_aggregations = orjson.loads(
(datadir / "es_aggregations_for_1735925.json").read_text()
)
with inspire_app.test_client() as client:
response = client.get("/jobs/facets")
response_data = response.json
response_status_code = response.status_code
response_aggregations = response_data["aggregations"]
expected_status_code = 200
assert expected_status_code == response_status_code
assert expected_aggregations == response_aggregations
assert len(response_data["hits"]["hits"]) == 0
def test_authors_detail_links(inspire_app):
expected_status_code = 200
record = create_record("aut")
expected_links = {
"json": f"http://localhost:5000/authors/{record['control_number']}?format=json"
}
with inspire_app.test_client() as client:
response = client.get(f"/authors/{record['control_number']}")
assert response.status_code == expected_status_code
assert response.json["links"] == expected_links
def test_institutions_application_json_put_without_auth(inspire_app):
record = create_record("ins")
record_control_number = record["control_number"]
expected_status_code = 401
with inspire_app.test_client() as client:
response = client.put(f"/institutions/{record_control_number}")
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_seminars_detail_submitter_can_edit(inspire_app):
with inspire_app.test_client() as client:
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
user = create_user(email="*****@*****.**", orcid="0000-0002-6665-4934")
create_record(
"sem",
data={
"acquisition_source": {
"email": "*****@*****.**",
"orcid": "0000-0002-6665-4934",
}
},
)
create_record(
"sem",
data={
"acquisition_source": {
"email": "*****@*****.**",
"orcid": "0000-0002-6665-1234",
}
},
)
login_user_via_session(client, email=user.email)
response = client.get("/seminars", headers=headers)
hits = response.json["hits"]["hits"]
own_job_metadata = next(
hit["metadata"]
for hit in hits
if hit["metadata"]["acquisition_source"]["email"] == user.email
)
another_job_metadata = next(
hit["metadata"]
for hit in hits
if hit["metadata"]["acquisition_source"]["email"] != user.email
)
assert not another_job_metadata["can_edit"]
assert own_job_metadata["can_edit"]
def test_citations_query_result(inspire_app):
record_control_number = 12345
# create self_citation
record_cited = create_record(
"lit",
data={"control_number": record_control_number},
literature_citations=[record_control_number],
)
# create correct citation
record_citing = create_record("lit",
literature_citations=[record_control_number])
with inspire_app.test_client() as client:
response = client.get(
f"api/literature/{record_control_number}/citations")
assert response.json["metadata"]["citation_count"] == 1
citation = response.json["metadata"]["citations"][0]
assert citation["control_number"] == record_citing["control_number"]
def test_format_conference_paper(inspire_app, datadir):
data = orjson.loads((datadir / "524480.json").read_text())
record = create_record("lit", data=data)
data_conference = orjson.loads((datadir / "972464.json").read_text())
record_conference = create_record_factory(
"con", data=data_conference, with_indexing=True
)
with inspire_app.test_client() as client:
response = client.get("/literature/524480")
assert response.status_code == 200
inproceedings = orjson.loads(response.data)
expected = xml_parse(
"""
<work:work xmlns:common="http://www.orcid.org/ns/common" xmlns:work="http://www.orcid.org/ns/work">
<work:title>
<common:title>CMB anisotropies: A Decadal survey</common:title>
</work:title>
<work:journal-title>4th RESCEU International Symposium on Birth and Evolution of the Universe</work:journal-title>
<work:type>conference-paper</work:type>
<common:external-ids>
<common:external-id>
<common:external-id-type>other-id</common:external-id-type>
<common:external-id-value>524480</common:external-id-value>
<common:external-id-url>http://inspirehep.net/record/524480</common:external-id-url>
<common:external-id-relationship>self</common:external-id-relationship>
</common:external-id>
<common:external-id>
<common:external-id-type>arxiv</common:external-id-type>
<common:external-id-value>astro-ph/0002520</common:external-id-value>
<common:external-id-url>http://arxiv.org/abs/astro-ph/0002520</common:external-id-url>
<common:external-id-relationship>self</common:external-id-relationship>
</common:external-id>
</common:external-ids>
<work:url>http://inspirehep.net/record/524480</work:url>
<work:contributors>
<work:contributor>
<work:credit-name>Hu, Wayne</work:credit-name>
<work:contributor-attributes>
<work:contributor-sequence>first</work:contributor-sequence>
<work:contributor-role>author</work:contributor-role>
</work:contributor-attributes>
</work:contributor>
</work:contributors>
</work:work>
"""
)
result = OrcidConverter(
inproceedings["metadata"], url_pattern="http://inspirehep.net/record/{recid}"
).get_xml()
assert valid_against_schema(result)
assert xml_compare(expected, result)
assert _OrcidHasher(mock.Mock())._hash_xml_element(expected) == _OrcidHasher(
mock.Mock()
)._hash_xml_element(result)
def test_indexer_creates_proper_fulltext_links_in_ui_display_files_enabled(
inspire_app, s3):
create_s3_bucket("1")
create_s3_bucket("f")
expected_fulltext_links = ["arXiv", "KEK scanned document", "fulltext"]
data = {
"external_system_identifiers": [
{
"schema": "OSTI",
"value": "7224300"
},
{
"schema": "ADS",
"value": "1994PhRvD..50.4491S"
},
{
"schema": "KEKSCAN",
"value": "94-07-219"
},
{
"schema": "SPIRES",
"value": "SPIRES-2926342"
},
],
"arxiv_eprints": [{
"categories": ["hep-ph"],
"value": "hep-ph/9404247"
}],
"documents": [
{
"source": "arxiv",
"fulltext": True,
"hidden": True,
"key": "arXiv:nucl-th_9310030.pdf",
"url": "https://arxiv.org/pdf/1910.11662.pdf",
},
{
"source":
"arxiv",
"key":
"arXiv:nucl-th_9310031.pdf",
"url":
"http://inspirehep.net/record/863300/files/fermilab-pub-10-255-e.pdf",
},
],
}
record = create_record("lit", data=data)
response = es_search("records-hep")
result = response["hits"]["hits"][0]["_source"]
result_ui_display = json.loads(result.pop("_ui_display"))
for link in result_ui_display["fulltext_links"]:
assert link["value"]
assert link["description"] in expected_fulltext_links
def test_literature_references_pagination(inspire_app):
record1 = create_record("lit", data=faker.record("lit"))
record2 = create_record("lit", data=faker.record("lit"))
record3 = create_record("lit", data=faker.record("lit"))
record4 = create_record("lit", data=faker.record("lit"))
data = faker.record(
"lit",
literature_citations=[
record1["control_number"],
record2["control_number"],
record3["control_number"],
record4["control_number"],
],
)
record_with_references = create_record("lit", data=data)
headers = {"Accept": "application/json"}
with inspire_app.test_client() as client:
response = client.get(
f"/literature/{record_with_references['control_number']}/references?page=2&size=2",
headers=headers,
)
response_status_code = response.status_code
response_data = json.loads(response.data)
response_data_metadata = response_data["metadata"]
expected_result = {
"references": [
{
"control_number": record3["control_number"],
"titles": record3["titles"]
},
{
"control_number": record4["control_number"],
"titles": record4["titles"]
},
],
"references_count":
4,
}
expected_status_code = 200
assert expected_status_code == response_status_code
assert expected_result == response_data_metadata
def test_link_signatures_to_author(inspire_app):
data_1 = {
"authors": [
{"full_name": "Doe, John", "uuid": "94fc2b0a-dc17-42c2-bae3-ca0024079e51"}
]
}
record_1 = create_record("lit", data=data_1)
data_2 = {
"authors": [
{"full_name": "Walker, Sam", "uuid": "94fc2b0a-dc17-42c2-bae3-ca0024079e52"}
]
}
record_2 = create_record("lit", data=data_2)
signatures_data = [
{
"publication_id": record_1["control_number"],
"signature_uuid": "94fc2b0a-dc17-42c2-bae3-ca0024079e51",
},
{
"publication_id": record_2["control_number"],
"signature_uuid": "94fc2b0a-dc17-42c2-bae3-ca0024079e52",
},
]
signatures = link_signatures_to_author(signatures_data, 123)
expected_signatures = [
{
"full_name": "Doe, John",
"uuid": "94fc2b0a-dc17-42c2-bae3-ca0024079e51",
"signature_block": "Dj",
"record": {"$ref": "http://localhost:5000/api/authors/123"},
},
{
"full_name": "Walker, Sam",
"uuid": "94fc2b0a-dc17-42c2-bae3-ca0024079e52",
"signature_block": "WALCARs",
"record": {"$ref": "http://localhost:5000/api/authors/123"},
},
]
expected_ref = "http://localhost:5000/api/authors/123"
assert expected_signatures == signatures
assert expected_ref == record_1["authors"][0]["record"]["$ref"]
assert expected_ref == record_2["authors"][0]["record"]["$ref"]
def test_record_links_when_correct_type_is_not_first_document_type_conference(
inspire_app, ):
conference = create_record("con")
conference_control_number = conference["control_number"]
ref = f"http://localhost:8000/api/conferences/{conference_control_number}"
conf_paper_data = {
"publication_info": [{
"conference_record": {
"$ref": ref
}
}],
"document_type": ["article", "conference paper"],
}
proceedings_data = {
"publication_info": [{
"conference_record": {
"$ref": ref
}
}],
"document_type": ["book", "proceedings", "thesis"],
}
rec_without_correct_type_data = {
"publication_info": [{
"conference_record": {
"$ref": ref
}
}],
"document_type": ["book", "thesis", "article"],
}
conf_paper_record = create_record("lit", conf_paper_data)
proceedings_record = create_record("lit", proceedings_data)
rec_without_correct_type = create_record("lit",
rec_without_correct_type_data)
documents = conference.model.conference_documents
conf_docs_uuids = [document.literature_uuid for document in documents]
assert len(documents) == 2
assert proceedings_record.id in conf_docs_uuids
assert conf_paper_record.id in conf_docs_uuids
assert rec_without_correct_type.id not in conf_docs_uuids
def test_literature_hidden_collection_as_logged_in_user_not_cataloger(
inspire_app):
expected_status_code = 403
rec = create_record("lit", data={"_collections": ["D0 Internal Notes"]})
user = create_user()
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/literature/{rec['control_number']}")
assert response.status_code == expected_status_code
def test_redirects_claims_to_author_page(inspire_app):
author_data = {
"control_number": 333,
"ids": [{
"schema": "INSPIRE BAI",
"value": "G.Aad.1"
}],
}
create_record("aut", data=author_data)
with inspire_app.test_client() as client:
response = client.get("/author/claim/G.Aad.1")
response_status_code = response.status_code
response_location_header = response.headers.get("Location")
expected_status_code = 302
expected_redirect_url = "http://localhost:5000/authors/333"
assert expected_status_code == response_status_code
assert response_location_header == expected_redirect_url
def test_literature_application_json_put_without_token(inspire_app):
record = create_record("lit")
record_control_number = record["control_number"]
headers = {"If-Match": '"0"'}
expected_status_code = 401
with inspire_app.test_client() as client:
response = client.put("/literature/{}".format(record_control_number),
headers=headers)
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_get_all_ids_by_update_date(inspire_app):
record = create_record("lit")
record2 = create_record("lit")
uuids = list(LiteratureRecord.get_recids_by_updated_datetime())
assert len(uuids) == 2
assert str(record.id) in uuids
assert str(record2.id) in uuids
uuids = list(InspireRecord.get_recids_by_updated_datetime())
assert len(uuids) == 0
new_date = datetime.strptime("2021-07-01", "%Y-%m-%d")
uuids = list(
LiteratureRecord.get_recids_by_updated_datetime(before=new_date))
assert len(uuids) == 0
uuids = list(
LiteratureRecord.get_recids_by_updated_datetime(after=new_date))
assert len(uuids) == 2
def test_proceedings_query_after_hard_delete(inspire_app):
conference = create_record("con")
conference_control_number = conference["control_number"]
ref = f"http://localhost:8000/api/conferences/{conference_control_number}"
rec_data = {
"publication_info": [{"conference_record": {"$ref": ref}}],
"document_type": ["proceedings"],
}
rec1 = create_record("lit", rec_data)
expected_proceedings_count = 1
expected_proceedings = [dict(rec1)]
assert expected_proceedings_count == len(conference.proceedings)
assert expected_proceedings == conference.proceedings
rec1.hard_delete()
expected_proceedings_count = 0
assert expected_proceedings_count == len(conference.proceedings)
def test_create_or_update_when_redirection_enabled_updates_original_record(
inspire_app):
rec_to_delete = create_record("lit")
rec_which_deletes = create_record(
"lit", data={"deleted_records": [rec_to_delete["self"]]})
expected_title = {"title": "New title"}
data = dict(
LiteratureRecord.get_record_by_pid_value(
rec_to_delete["control_number"], original_record=True))
data["titles"][0] = expected_title
InspireRecord.create_or_update(data)
deleted_rec = LiteratureRecord.get_record_by_pid_value(
rec_to_delete["control_number"], original_record=True)
new_rec = LiteratureRecord.get_record_by_pid_value(
rec_which_deletes["control_number"])
assert deleted_rec["titles"][0] == expected_title
assert new_rec["titles"][0] == rec_which_deletes["titles"][0]
def test_redirect_wrong_new_pid_status(inspire_app):
record_1 = create_record("lit")
record_2 = create_record("lit")
record_2_pid = record_2.control_number_pid
record_2_pid.status = PIDStatus.DELETED
record_2_data = dict(record_2)
record_2_data["deleted_records"] = [record_1["self"]]
with pytest.raises(WrongRedirectionPidStatus):
record_2.update(record_2_data)
record_1_from_db = LiteratureRecord.get_record_by_pid_value(
record_1["control_number"])
record_2_from_db = LiteratureRecord.get_record_by_pid_value(
record_2["control_number"])
assert record_1_from_db.id == record_1.id
assert record_2_from_db.id == record_2.id
def test_redirect_and_delete_record_from_deleted_records_field(inspire_app):
record_to_delete = create_record("lit")
record = create_record("lit")
data = dict(record)
data["deleted_records"] = [record_to_delete["self"]]
record.update(data)
deleted_records = record["deleted_records"]
assert len(deleted_records) == 1
old_pid = record_to_delete.control_number_pid
assert old_pid.is_redirected()
record_redirected = LiteratureRecord.get_record_by_pid_value(
record_to_delete.control_number)
assert record_redirected.id == record.id
original_record = LiteratureRecord.get_record(record_to_delete.id,
with_deleted=True)
assert original_record["deleted"] is True
def test_indexer_deletes_record_from_es(inspire_app):
record = create_record("sem")
record["deleted"] = True
record.index(delay=False)
current_search.flush_and_refresh("records-seminars")
expected_records_count = 0
record_lit_es = SeminarsSearch().get_record(str(record.id)).execute().hits
assert expected_records_count == len(record_lit_es)
def test_bibtext_do_not_add_bibtex_citation(inspire_app, datadir):
data = orjson.loads(
(datadir / "test_orcid_converter_TestBibtexCitation.json").read_text()
)
record = create_record("lit", data=data)
converter = OrcidConverter(
record=record, url_pattern="http://inspirehep.net/record/{recid}"
)
xml_root = converter.get_xml()
top_level_tags = [etree.QName(node).localname for node in xml_root.getchildren()]
assert "citation" not in top_level_tags
