def test_predecessor_institutions_in_detail_page(inspire_app):
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
data = {"legacy_ICN": "Ins Parent"}
record = create_record_factory("ins", data=data)
record_control_number = record.json["control_number"]
data = {
"related_records": [{
"record": {
"$ref":
f"https://inspirebeta.net/api/institutions/{record_control_number}"
},
"relation": "predecessor",
"curated_relation": True,
}],
"number_of_papers":
0,
}
expected_predecessor_institutions_data = [{
"control_number": record_control_number,
"legacy_ICN": "Ins Parent"
}]
record = create_record_factory("ins", data=data)
record_control_number = record.json["control_number"]
with inspire_app.test_client() as client:
response = client.get(f"/institutions/{record_control_number}",
headers=headers)
response_data = json.loads(response.data)
response_data_metadata = response_data["metadata"]
assert (response_data_metadata["predecessor_institutions"] ==
expected_predecessor_institutions_data)
def test_get_linked_records_in_field_with_different_pid_types(inspire_app):
record_reference_lit = create_record_factory("lit")
record_reference_lit_control_number = record_reference_lit.json["control_number"]
record_reference_lit_uri = "http://localhost:5000/api/literature/{}".format(
record_reference_lit_control_number
)
record_reference_aut = create_record_factory("aut")
record_reference_aut_control_number = record_reference_aut.json["control_number"]
record_reference_aut_uri = "http://localhost:5000/api/authors/{}".format(
record_reference_aut_control_number
)
data = {
"references": [
{"record": {"$ref": record_reference_lit_uri}},
{"record": {"$ref": record_reference_aut_uri}},
]
}
record = create_record_factory("lit", data=data)
expected_result_len = 2
expected_result = [record_reference_lit.json, record_reference_aut.json]
result = LiteratureRecord.get_record_by_pid_value(
record.json["control_number"]
).get_linked_records_from_field("references.record")
result = list(result)
assert expected_result_len == len(result)
for record in result:
assert record in expected_result
def test_successor_experiments_in_detail_page(inspire_app):
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
data = {"legacy_name": "Experiment 1"}
record = create_record_factory("exp", data=data)
record_control_number = record.json["control_number"]
data = {
"related_records": [{
"record": {
"$ref":
f"https://inspirebeta.net/api/experiments/{record_control_number}"
},
"relation": "successor",
"curated_relation": True,
}]
}
expected_successor_experiments_data = [{
"control_number": record_control_number,
"legacy_name": "Experiment 1"
}]
record = create_record_factory("exp", data=data)
record_control_number = record.json["control_number"]
with inspire_app.test_client() as client:
response = client.get(f"/experiments/{record_control_number}",
headers=headers)
response_data = orjson.loads(response.data)
response_data_metadata = response_data["metadata"]
assert (response_data_metadata["successor_experiments"] ==
expected_successor_experiments_data)
def test_citation_summary_facet_excluded_filters(inspire_app):
non_refereed_paper = {
"refereed": False,
"citation_count": 8,
"facet_author_name": "NOREC_N. Girard",
"citeable": True,
}
create_record_factory("lit", data=non_refereed_paper, with_indexing=True)
published_papers_citation_count = [409, 83, 26, 153, 114, 97, 137]
for count in published_papers_citation_count:
data = {
"refereed": True,
"citation_count": count,
"facet_author_name": "NOREC_N. Girard",
"citeable": True,
}
create_record_factory("lit", data=data, with_indexing=True)
with inspire_app.test_client() as client:
response = client.get(
"/literature/facets?author=NOREC_N.%20Girard&facet_name=citation-summary&refereed=True&citeable=False&citation_count=500--505"
)
response_data = orjson.loads(response.data)
response_status_code = response.status_code
assert response_status_code == 200
assert response_data["aggregations"]["citation_summary"]["doc_count"] == 8
def test_seminars_search_json_get(inspire_app):
create_record_factory("sem", with_indexing=True)
expected_status_code = 200
with inspire_app.test_client() as client:
response = client.get("/seminars")
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_minter_orcid_already_existing(inspire_app):
orcid_value = faker.orcid()
data = {"ids": [{"value": orcid_value, "schema": "ORCID"}]}
record_with_orcid = create_record_factory("aut", data=data)
OrcidMinter.mint(record_with_orcid.id, record_with_orcid.json)
record_with_existing_orcid = create_record_factory("aut", data)
with pytest.raises(PIDAlreadyExists):
OrcidMinter.mint(record_with_existing_orcid.id, record_with_existing_orcid.json)
def test_mitner_arxiv_eprints_already_existing(inspire_app):
arxiv_value = faker.arxiv()
data = {"arxiv_eprints": [{"value": arxiv_value}]}
record_with_arxiv = create_record_factory("lit", data=data, with_validation=True)
ArxivMinter.mint(record_with_arxiv.id, record_with_arxiv.json)
record_with_existing_arxiv = create_record_factory("lit", data)
with pytest.raises(PIDAlreadyExists):
ArxivMinter.mint(record_with_existing_arxiv.id, record_with_existing_arxiv.json)
def test_reindex_one_type_of_record(inspire_app, cli):
record_lit = create_record_factory("lit")
create_record_factory("aut")
cli.invoke(["index", "reindex", "-p", "lit"])
current_search.flush_and_refresh("*")
expected_aut_len = 0
results_lit_uuid = LiteratureSearch().execute().hits.hits[0]["_id"]
results_aut_len = len(AuthorsSearch().execute().hits.hits)
assert str(record_lit.id) == results_lit_uuid
assert expected_aut_len == results_aut_len
def test_base_get_records(inspire_app):
records = [
create_record_factory("lit"),
create_record_factory("lit"),
create_record_factory("lit"),
]
record_uuids = [record.id for record in records]
expected_records = InspireRecord.get_records(record_uuids)
for record in records:
assert record.json in expected_records
def test_mitner_dois_already_existing(inspire_app):
doi_value = faker.doi()
data = {"dois": [{"value": doi_value}]}
record_with_doi = create_record_factory("lit",
data=data,
with_validation=True)
DoiMinter.mint(record_with_doi.id, record_with_doi.json)
record_with_existing_doi = create_record_factory("lit", data)
with pytest.raises(PIDAlreadyExists):
DoiMinter.mint(record_with_existing_doi.id,
record_with_existing_doi.json)
def test_literature_search_citeable_filter(inspire_app):
citeable_paper = create_record_factory("lit",
data={"citeable": True},
with_indexing=True)
create_record_factory("lit", data={"citeable": False}, with_indexing=True)
with inspire_app.test_client() as client:
response = client.get("/literature?citeable=true")
response_data = orjson.loads(response.data)
response_status_code = response.status_code
assert response_status_code == 200
assert response_data["hits"]["total"] == 1
assert (response_data["hits"]["hits"][0]["metadata"]["control_number"] ==
citeable_paper.json["control_number"])
def test_experiments_json_without_login(inspire_app, datadir):
headers = {"Accept": "application/json"}
data = orjson.loads((datadir / "1108739.json").read_text())
record = create_record_factory("exp", data=data)
record_control_number = record.json["control_number"]
expected_metadata = deepcopy(record.json)
del expected_metadata["_collections"]
del expected_metadata["_private_notes"]
expected_metadata["number_of_papers"] = 0
expected_created = utils.isoformat(record.created)
expected_updated = utils.isoformat(record.updated)
with inspire_app.test_client() as client:
response = client.get(f"/experiments/{record_control_number}",
headers=headers)
response_data = orjson.loads(response.data)
response_data_metadata = response_data["metadata"]
response_created = response_data["created"]
response_updated = response_data["updated"]
assert expected_metadata == response_data_metadata
assert expected_created == response_created
assert expected_updated == response_updated
def test_experiments_json_with_loggedin_cataloger(inspire_app, datadir):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = orjson.loads((datadir / "1108739.json").read_text())
record = create_record_factory("exp", data=data)
record_control_number = record.json["control_number"]
expected_metadata = deepcopy(record.json)
expected_metadata["number_of_papers"] = 0
expected_created = utils.isoformat(record.created)
expected_updated = utils.isoformat(record.updated)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/experiments/{record_control_number}",
headers=headers)
response_data = orjson.loads(response.data)
response_data_metadata = response_data["metadata"]
response_created = response_data["created"]
response_updated = response_data["updated"]
assert expected_metadata == response_data_metadata
assert expected_created == response_created
assert expected_updated == response_updated
def test_minter_orcid(inspire_app):
orcid_value = faker.orcid()
data = {
"ids": [
{
"schema": "JACOW",
"value": "JACoW-12345678"
},
{
"schema": "ORCID",
"value": orcid_value
},
]
}
record = create_record_factory("aut", data=data)
data = record.json
OrcidMinter.mint(record.id, data)
expected_pids_len = 1
epxected_pids_values = [orcid_value]
expected_pids_provider = "external"
expected_pids_status = PIDStatus.REGISTERED
result_pids = (PersistentIdentifier.query.filter_by(
object_uuid=record.id).filter_by(pid_type="orcid").all())
result_pids_len = len(result_pids)
assert expected_pids_len == result_pids_len
pid = result_pids[0]
assert expected_pids_provider == pid.pid_provider
assert expected_pids_status == pid.status
assert pid.pid_value in epxected_pids_values
def test_minter_arxiv_eprints(inspire_app):
arxiv_value_1 = faker.arxiv()
arxiv_value_2 = faker.arxiv()
data = {
"arxiv_eprints": [{
"value": arxiv_value_1
}, {
"value": arxiv_value_2
}]
}
record = create_record_factory("lit", data=data, with_validation=True)
data = record.json
ArxivMinter.mint(record.id, data)
expected_pids_len = 2
epxected_pids_values = [arxiv_value_1, arxiv_value_2]
expected_pids_provider = "external"
expected_pids_status = PIDStatus.REGISTERED
result_pids = (PersistentIdentifier.query.filter_by(
object_uuid=record.id).filter_by(pid_type="arxiv").all())
result_pids_len = len(result_pids)
assert expected_pids_len == result_pids_len
for pid in result_pids:
assert expected_pids_provider == pid.pid_provider
assert expected_pids_status == pid.status
assert pid.pid_value in epxected_pids_values
def test_minter_arxiv_eprints_duplicate(inspire_app):
arxiv_value_1 = faker.arxiv()
data = {
"arxiv_eprints": [
{
"value": arxiv_value_1,
"categories": ["cond-mat"]
},
{
"value": arxiv_value_1,
"categories": ["astro-ph"]
},
]
}
record = create_record_factory("lit", data=data, with_validation=True)
data = record.json
ArxivMinter.mint(record.id, data)
epxected_pid_value = arxiv_value_1
expected_pid_provider = "external"
expected_pid_status = PIDStatus.REGISTERED
result_pid = (PersistentIdentifier.query.filter_by(
object_uuid=record.id).filter_by(pid_type="arxiv").one())
assert expected_pid_provider == result_pid.pid_provider
assert expected_pid_status == result_pid.status
assert epxected_pid_value == result_pid.pid_value
def test_regression_hard_delete_record_with_string_pid_value(inspire_app):
record_factory = create_record_factory("lit", with_indexing=True)
create_pidstore(record_factory.id, "pid1", "STRING")
pid_value_rec = record_factory.json["control_number"]
record_uuid = record_factory.id
record = InspireRecord.get_record(record_uuid)
record_pids = PersistentIdentifier.query.filter_by(object_uuid=record.id).all()
assert 2 == len(record_pids)
assert record_factory.json == record
record.hard_delete()
record = RecordMetadata.query.filter_by(id=record_uuid).one_or_none()
record_pids = PersistentIdentifier.query.filter_by(
object_uuid=record_uuid
).one_or_none()
record_identifier = RecordIdentifier.query.filter_by(
recid=pid_value_rec
).one_or_none()
assert record is None
assert record_pids is None
assert record_identifier is None
def test_hard_delete_record(inspire_app):
record_factory = create_record_factory("lit")
create_pidstore(record_factory.id, "pid1", faker.control_number())
create_pidstore(record_factory.id, "pid2", faker.control_number())
create_pidstore(record_factory.id, "pid3", faker.control_number())
pid_value_rec = record_factory.json["control_number"]
record_uuid = record_factory.id
record = InspireRecord.get_record(record_uuid)
record_pids = PersistentIdentifier.query.filter_by(object_uuid=record.id).all()
assert 4 == len(record_pids)
assert record_factory.json == record
record.hard_delete()
record = RecordMetadata.query.filter_by(id=record_uuid).one_or_none()
record_pids = PersistentIdentifier.query.filter_by(
object_uuid=record_uuid
).one_or_none()
record_identifier = RecordIdentifier.query.filter_by(
recid=pid_value_rec
).one_or_none()
assert record is None
assert record_pids is None
assert record_identifier is None
def test_minter_dois_duplicate(inspire_app):
doi_value_1 = faker.doi()
data = {
"dois": [
{
"value": doi_value_1,
"material": "data"
},
{
"value": doi_value_1,
"material": "erratum"
},
]
}
record = create_record_factory("lit", data=data, with_validation=True)
data = record.json
DoiMinter.mint(record.id, data)
epxected_pid_value = doi_value_1
expected_pid_provider = "external"
expected_pid_status = PIDStatus.REGISTERED
result_pid = (PersistentIdentifier.query.filter_by(
object_uuid=record.id).filter_by(pid_type="doi").one())
assert expected_pid_provider == result_pid.pid_provider
assert expected_pid_status == result_pid.status
assert epxected_pid_value == result_pid.pid_value
def test_latex_us(inspire_app):
headers = {"Accept": "application/vnd+inspire.latex.us+x-latex"}
data = {
"control_number": 637_275_237,
"titles": [{
"title": "This is a title."
}]
}
record = create_record_factory("lit", data=data, with_indexing=True)
record_control_number = record.json["control_number"]
expected_status_code = 200
expected_result = ("%\\cite{637275237}\n"
"\\bibitem{637275237}\n"
"%``This is a title.,''\n"
"%0 citations counted in INSPIRE as of 19 Dec 1994")
with inspire_app.test_client() as client:
response = client.get(f"/literature/{record_control_number}",
headers=headers)
response_status_code = response.status_code
response_data = response.get_data(as_text=True)
assert expected_status_code == response_status_code
assert expected_result == response_data
def test_reindex_all_types_records(inspire_app, cli):
record_lit = create_record_factory("lit")
record_aut = create_record_factory("aut")
record_job = create_record_factory("job")
record_con = create_record_factory("con")
cli.invoke(["index", "reindex", "--all"])
current_search.flush_and_refresh("*")
results_lit_uuid = LiteratureSearch().execute().hits.hits[0]["_id"]
results_aut_uuid = AuthorsSearch().execute().hits.hits[0]["_id"]
results_con_uuid = ConferencesSearch().execute().hits.hits[0]["_id"]
results_job_uuid = JobsSearch().execute().hits.hits[0]["_id"]
assert str(record_lit.id) == results_lit_uuid
assert str(record_aut.id) == results_aut_uuid
assert str(record_con.id) == results_con_uuid
assert str(record_job.id) == results_job_uuid
def test_get_records_by_pids(inspire_app):
records = [
create_record_factory("lit"),
create_record_factory("lit"),
create_record_factory("lit"),
]
pids = [("lit", str(record.json["control_number"])) for record in records]
expected_result_len = 3
expected_result = [record.json for record in records]
result = InspireRecord.get_records_by_pids(pids)
result = list(result)
assert expected_result_len == len(result)
for record in result:
assert record in expected_result
def test_literature_search_citation_count_filter(inspire_app):
paper_with_requested_number_of_citations = create_record_factory(
"lit", data={"citation_count": 101}, with_indexing=True)
papers_citation_count = [409, 83, 26]
for count in papers_citation_count:
create_record_factory("lit",
data={"citation_count": count},
with_indexing=True)
with inspire_app.test_client() as client:
response = client.get("/literature?citation_count=101--102")
response_data = orjson.loads(response.data)
response_status_code = response.status_code
assert response_status_code == 200
assert response_data["hits"]["total"] == 1
assert (response_data["hits"]["hits"][0]["metadata"]["control_number"] ==
paper_with_requested_number_of_citations.json["control_number"])
def test_seminars_application_json_delete(inspire_app):
record = create_record_factory("sem", with_indexing=True)
record_control_number = record.json["control_number"]
expected_status_code = 401
with inspire_app.test_client() as client:
response = client.delete(f"/seminars/{record_control_number}")
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_experiments_application_json_get(inspire_app):
record = create_record_factory("exp", with_indexing=True)
record_control_number = record.json["control_number"]
expected_status_code = 200
with inspire_app.test_client() as client:
response = client.get(f"/experiments/{record_control_number}")
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_journals_application_json_put(inspire_app):
record = create_record_factory("jou", with_indexing=True)
record_control_number = record.json["control_number"]
expected_status_code = 401
with inspire_app.test_client() as client:
response = client.put(f"/journals/{record_control_number}")
response_status_code = response.status_code
assert expected_status_code == response_status_code
def test_get_uuid_from_pid_value(inspire_app):
record = create_record_factory("lit")
record_uuid = record.id
record_pid_type = record._persistent_identifier.pid_type
record_pid_value = record._persistent_identifier.pid_value
expected_record_uuid = InspireRecord.get_uuid_from_pid_value(
record_pid_value, pid_type=record_pid_type)
assert expected_record_uuid == record_uuid
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_minter_orcid_missing_schema(inspire_app):
orcid_value = faker.orcid()
data = {"ids": [{"value": orcid_value, "schema": "ORCID"}]}
record = create_record_factory("aut", data=data)
record_data = record.json
record_id = record.id
record_data.pop("$schema")
with pytest.raises(MissingSchema):
OrcidMinter.mint(record_id, record_data)
def test_mitner_arxiv_eprints_missing_schema(inspire_app):
arxiv_value = faker.arxiv()
data = {"arxiv_eprints": [{"value": arxiv_value}]}
record = create_record_factory("lit", data=data)
record_data = record.json
record_id = record.id
record_data.pop("$schema")
with pytest.raises(MissingSchema):
ArxivMinter.mint(record_id, record_data)
