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)