def assert_continuous_migration(): record_citer = InspireRecord.get_record_by_pid_value( citer_control_number, "lit") record_cited = InspireRecord.get_record_by_pid_value( cited_control_number, "lit") assert record_cited.citation_count == 1 record_citer_es = InspireSearch.get_record_data_from_es(record_citer) result_citer_control_number = record_citer_es["control_number"] assert citer_control_number == result_citer_control_number record_cited_es = InspireSearch.get_record_data_from_es(record_cited) result_cited_control_number = record_cited_es["control_number"] assert cited_control_number == result_cited_control_number with inspire_app.test_client() as client: result = client.get( f"/api/literature/{result_cited_control_number}/citations" ).json result_citation_count = result["metadata"]["citation_count"] assert 1 == result_citation_count assert redis.llen("legacy_records") == 0
def assert_migrator_task(): record_citer = InspireRecord.get_record_by_pid_value( citer_control_number, "lit") record_citing = InspireRecord.get_record_by_pid_value( citing_control_number, "lit") record_author = InspireRecord.get_record_by_pid_value( author_control_number, "aut") assert record_citing.citation_count == 1 record_citer_es = InspireSearch.get_record_data_from_es(record_citer) result_citer_control_number = record_citer_es["control_number"] assert citer_control_number == result_citer_control_number record_citing_es = InspireSearch.get_record_data_from_es(record_citing) result_citing_control_number = record_citing_es["control_number"] assert citing_control_number == result_citing_control_number record_author_es = InspireSearch.get_record_data_from_es(record_author) result_author_control_number = record_author_es["control_number"] assert author_control_number == result_author_control_number with pytest.raises(PIDDoesNotExistError): InspireRecord.get_record_by_pid_value(invalid_control_number, "lit")
def test_create_records_from_mirror_recids_with_different_types_of_record(inspire_app): raw_record_literature_valid = ( b"<record>" b' <controlfield tag="001">666</controlfield>' b' <datafield tag="245" ind1=" " ind2=" ">' b' <subfield code="a">On the validity of INSPIRE records</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b"</record>" ) valid_record_literature = LegacyRecordsMirror.from_marcxml( raw_record_literature_valid ) db.session.add(valid_record_literature) raw_record_invalid = ( b"<record>" b' <controlfield tag="001">667</controlfield>' b' <datafield tag="260" ind1=" " ind2=" ">' b' <subfield code="c">Definitely not a date</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b"</record>" ) invalid_record = LegacyRecordsMirror.from_marcxml(raw_record_invalid) db.session.add(invalid_record) raw_record_author_valid = ( b"<record>" b' <controlfield tag="001">668</controlfield>' b' <datafield tag="100" ind1=" " ind2=" ">' b' <subfield code="a">Jessica Jones</subfield>' b' <subfield code="q">Jones Jessica</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEPNAMES</subfield>' b" </datafield>" b"</record>" ) valid_record_author = LegacyRecordsMirror.from_marcxml(raw_record_author_valid) db.session.add(valid_record_author) task_results = create_records_from_mirror_recids([666, 667, 668]) record_literature = InspireRecord.get_record_by_pid_value(666, "lit") assert str(record_literature.id) in task_results record_author = InspireRecord.get_record_by_pid_value(668, "aut") assert str(record_author.id) in task_results with pytest.raises(PIDDoesNotExistError): InspireRecord.get_record_by_pid_value(667, "lit")
def test_orcid_is_not_updated_if_was_moved_but_already_in_ids( inspire_app, user_remote_account): old_orcid = user_remote_account.remote_account.extra_data["orcid"] new_orcid = "0000-0002-1825-0097" data = { "$schema": "http://localhost:5000/schemas/records/authors.json", "_collections": ["Authors"], "control_number": 123456789, "ids": [ { "schema": "INSPIRE BAI", "value": "J.Smith.1" }, { "schema": "ORCID", "value": new_orcid }, { "schema": "ORCID", "value": old_orcid }, ], "name": { "value": "Smith, John" }, } rec = create_record("aut", data=data) db.session.commit() update_moved_orcid(old_orcid, new_orcid) author_record = InspireRecord.get_record_by_pid_value( rec["control_number"], "aut") assert data["ids"] == author_record.get("ids", [])
def get_record_and_schema(endpoint, pid_value): pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value(pid_value, pid_type, original_record=True) if not check_permissions_for_private_collection_read( record.get("_collections", [])): return jsonify(message="Unauthorized", code=403), 403 editor_soft_lock_service = EditorSoftLock( recid=record["control_number"], record_version=record.model.version_id, user_email=current_user.email, ) editor_lock_payload = editor_soft_lock_service.prepare_editor_lock_api_payload( ) editor_soft_lock_service.add_lock() json = { "record": { "metadata": record }, "schema": load_schema(record["$schema"]), } json.update(editor_lock_payload) response = make_response(json) set_headers_for_record_caching_and_concurrency(response, record) return response
def test_push_happy_flow(inspire_app, get_fixture): record_json = orjson.loads(get_fixture("hal_preprod_record.json")) record_data = faker.record("lit", data=record_json) record = InspireRecord.create(record_data) institute_json = orjson.loads(get_fixture("hal_preprod_institute.json")) institute_data = faker.record("ins", data=institute_json) InspireRecord.create(institute_data) # hal create receipt = _hal_push(record) assert receipt assert receipt.parsed hal_id = receipt.id assert hal_id updated_record = InspireRecord.get_record_by_pid_value( record["control_number"], "lit" ) assert ( get_values_for_schema( get_value(updated_record, "external_system_identifiers", []), "HAL" )[0] == hal_id ) # hal update receipt = _hal_push(record) assert receipt assert receipt.parsed
def get_revisions(endpoint, pid_value): """Get revisions of given record""" try: Transaction = transaction_class(RecordMetadata) pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value(pid_value, pid_type, original_record=True) if not check_permissions_for_private_collection_read( record.get("_collections", [])): return jsonify(message="Unauthorized", code=403), 403 revisions = [] for revision in reversed(record.revisions): transaction_id = revision.model.transaction_id user = Transaction.query.filter( Transaction.id == transaction_id).one().user if user: user_email = user.email else: user_email = "system" revisions.append({ "updated": revision.updated, "revision_id": revision.revision_id, "user_email": user_email, "transaction_id": transaction_id, "rec_uuid": record.id, }) return jsonify(revisions) except Exception: raise EditorGetRevisionError
def test_clean_stub_authors_doesnt_remove_stub_authors_with_linked_papers( inspire_app, cli): stub_author_data = { "stub": True, "name": { "value": "'t Hooft, Gerardus" }, "ids": [{ "value": "G.Hooft.2", "schema": "INSPIRE BAI" }], } stub_author = create_record("aut", data=stub_author_data) lit_record_data = { "authors": [{ "full_name": "'t Hooft, Gerardus", "ids": stub_author_data["ids"] }] } create_record("lit", lit_record_data) cli.invoke(["disambiguation", "clean_stub_authors"]) stub_record = InspireRecord.get_record_by_pid_value( stub_author["control_number"], "aut", with_deleted=True) assert not stub_record.get("deleted")
def test_id_is_not_written_to_record_for_stale_data_push( mock_hal_create, mock_update_record_with_new_ids, inspire_app, get_fixture ): hal_create_receipt = Deposit_Receipt() hal_create_receipt.id = "hal:123456" mock_hal_create.return_value = hal_create_receipt def side_effect(*args, **kwargs): if side_effect.counter == 0: side_effect.counter += 1 raise StaleDataError else: return update_record_with_new_ids(*args, **kwargs) side_effect.counter = 0 mock_update_record_with_new_ids.side_effect = side_effect record_json = orjson.loads(get_fixture("hal_preprod_record.json")) record_data = faker.record("lit", data=record_json) record = InspireRecord.create(record_data) institute_json = orjson.loads(get_fixture("hal_preprod_institute.json")) institute_data = faker.record("ins", data=institute_json) InspireRecord.create(institute_data) _hal_push(record) record = InspireRecord.get_record_by_pid_value(record["control_number"], "lit") assert get_values_for_schema(record["external_system_identifiers"], "HAL") == [ "hal:123456" ]
def test_recalculate_citations(app, celery_app_with_context, celery_session_worker): data_cited = faker.record("lit", with_control_number=True) record_cited = InspireRecord.create(data_cited, disable_citation_update=True) db.session.commit() record_cited_control_number = record_cited["control_number"] data_citing = faker.record( "lit", literature_citations=[record_cited_control_number], with_control_number=True, ) record_citing = InspireRecord.create(data_citing, disable_citation_update=True) db.session.commit() uuids = [record_cited.id, record_citing.id] task = recalculate_citations.delay(uuids) task.get(timeout=5) result_record_cited = RecordCitations.query.filter_by( cited_id=record_cited.id).one() assert record_citing.id == result_record_cited.citer_id record_cited = InspireRecord.get_record_by_pid_value( record_cited_control_number, "lit") record_cited_citation_count = 1 assert record_cited_citation_count == record_cited.citation_count
def get_conference_record(record, default=None): """Return the first Conference record associated with a record. Queries the database to fetch the first Conference record referenced in the ``publication_info`` of the record. Args: record(InspireRecord): a record. default: value to be returned if no conference record present/found Returns: InspireRecord: the first Conference record associated with the record. Examples: >>> record = { ... 'publication_info': [ ... { ... 'conference_record': { ... '$ref': '/api/conferences/972464', ... }, ... }, ... ], ... } >>> conference_record = get_conference_record(record) >>> conference_record['control_number'] 972464 """ pub_info = record.get_value("publication_info.conference_record[0]") if not pub_info: return default return InspireRecord.get_record_by_pid_value(get_recid_from_ref(pub_info), "con")
def get_revisions(endpoint, pid_value): """Get revisions of given record""" try: Transaction = transaction_class(RecordMetadata) pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value(pid_value, pid_type) revisions = [] for revision in reversed(record.revisions): transaction_id = revision.model.transaction_id user = Transaction.query.filter(Transaction.id == transaction_id).one().user if user: user_email = user.email else: user_email = "system" revisions.append( { "updated": revision.updated, "revision_id": revision.revision_id, "user_email": user_email, "transaction_id": transaction_id, "rec_uuid": record.id, } ) return jsonify(revisions) except Exception: raise EditorGetRevisionError
def assert_migrator_task(): record_citer = InspireRecord.get_record_by_pid_value( citer_control_number, "lit") record_citing = InspireRecord.get_record_by_pid_value( citing_control_number, "lit") assert record_citing.citation_count == 1 record_citer_es = InspireSearch.get_record_data_from_es(record_citer) result_citer_control_number = record_citer_es["control_number"] assert citer_control_number == result_citer_control_number record_citing_es = InspireSearch.get_record_data_from_es(record_citing) result_citing_control_number = record_citing_es["control_number"] assert citing_control_number == result_citing_control_number
def test_continuous_migration_with_invalid_control_number( app, cache, celery_app_with_context, celery_session_worker): raw_record_citer = ( b"<record>" b' <controlfield tag="001">666</controlfield>' b' <datafield tag="245" ind1=" " ind2=" ">' b' <subfield code="a">This is a citer record</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b' <datafield tag="999" ind1="C" ind2="5">' b' <subfield code="0">667</subfield>' b' <subfield code="h">Achasov, M.N.</subfield>' b' <subfield code="k">snd-2018</subfield>' b' <subfield code="m">(SND Collaboration)</subfield>' b' <subfield code="o">2</subfield>' b' <subfield code="s">Phys.Rev.,D97,012008</subfield>' b' <subfield code="x">' b" [2] M. N. Achasov (SND Collaboration), Phys. Rev. D 97, 012008 (2018)." b" </subfield>" b' <subfield code="y">2018</subfield>' b' <subfield code="z">0</subfield>' b' <subfield code="z">1</subfield>' b" </datafield>" b"</record>") citer_control_number = 666 raw_record_cited = ( b"<record>" b' <controlfield tag="001">this is not a control number</controlfield>' b' <datafield tag="245" ind1=" " ind2=" ">' b' <subfield code="a">This is a citing record</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b"</record>") cache.rpush("legacy_records", zlib.compress(raw_record_citer)) cache.rpush("legacy_records", zlib.compress(raw_record_cited)) assert cache.llen("legacy_records") == 2 with pytest.raises(ValueError): continuous_migration() record_citer = InspireRecord.get_record_by_pid_value( citer_control_number, "lit") record_citer_es = InspireSearch.get_record_data_from_es(record_citer) result_citer_control_number = record_citer_es["control_number"] assert citer_control_number == result_citer_control_number # I don't like timeouts, it's the only way to wait for this chain time.sleep(5) assert cache.llen("legacy_records") == 1
def test_get_literature_recids_for_orcid_raises_if_two_authors_are_found( inspire_app, datadir): data = json.loads((datadir / "1061000.json").read_text()) create_record("aut", data=data) record = InspireRecord.get_record_by_pid_value(1061000, pid_type="aut") record["control_number"] = 1061001 with pytest.raises(PIDAlreadyExists): record = InspireRecord.create_or_update(record)
def get_record_and_schema(endpoint, pid_value): pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value(pid_value, pid_type) return jsonify({ "record": { "metadata": record }, "schema": load_schema(record["$schema"]) })
def test_get_literature_recids_for_orcid_still_works_if_author_has_no_ids( inspire_app, datadir): data = json.loads((datadir / "1061000.json").read_text()) create_record("aut", data=data) record = InspireRecord.get_record_by_pid_value(1061000, pid_type="aut") del record["ids"] record = InspireRecord.create_or_update(record) with pytest.raises(NoResultFound): get_literature_recids_for_orcid("0000-0003-4792-9178")
def test_assign_author_to_papers(inspire_app, override_config): with override_config(FEATURE_FLAG_ENABLE_ASSIGN_AUTHOR_PAPERS=True, ): lit_record = create_record( "lit", data={ "authors": [{ "full_name": "Test Author", "ids": [{ "schema": "INSPIRE BAI", "value": "T.Author.1" }], }] }, ) lit_record_1 = create_record( "lit", data={ "authors": [{ "full_name": "Test Author", "ids": [{ "schema": "INSPIRE BAI", "value": "T.Author.1" }], }] }, ) record = create_record( "aut", data={"ids": [{ "schema": "INSPIRE BAI", "value": "T.Author.1" }]}) lit_record_db = InspireRecord.get_record_by_pid_value( lit_record["control_number"], "lit") lit_record_1_db = InspireRecord.get_record_by_pid_value( lit_record_1["control_number"], "lit") assert lit_record_db["authors"][0]["record"] == record["self"] assert lit_record_1_db["authors"][0]["record"] == record["self"]
def revert_to_revision(endpoint, pid_value): """Revert given record to given revision""" try: pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value(pid_value, pid_type) revision_id = request.json["revision_id"] record.revert(revision_id) db.session.commit() return jsonify(success=True) except Exception: raise EditorRevertToRevisionError
def get_record_and_schema(endpoint, pid_value): pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value( pid_value, pid_type, original_record=True ) json = {"record": {"metadata": record}, "schema": load_schema(record["$schema"])} response = make_response(json) set_headers_for_record_caching_and_concurrency(response, record) return response
def test_migrating_deleted_record_registers_control_number_regression(inspire_app): raw_deleted_record = b'<record>\n <controlfield tag="001">1775082</controlfield>\n <controlfield tag="005">20200131230810.0</controlfield>\n <datafield tag="856" ind1="4" ind2=" ">\n <subfield code="u">https://gambit.hepforge.org/</subfield>\n </datafield>\n <datafield tag="909" ind1="C" ind2="O">\n <subfield code="o">oai:inspirehep.net:1775082</subfield>\n <subfield code="q">INSPIRE:Experiments</subfield>\n </datafield>\n <datafield tag="961" ind1=" " ind2=" ">\n <subfield code="x">2020-01-13</subfield>\n <subfield code="c">2020-01-31</subfield>\n </datafield>\n <datafield tag="980" ind1=" " ind2=" ">\n <subfield code="a">CORE</subfield>\n </datafield>\n <datafield tag="980" ind1=" " ind2=" ">\n <subfield code="a">EXPERIMENT</subfield>\n </datafield>\n <datafield tag="980" ind1=" " ind2=" ">\n <subfield code="c">DELETED</subfield>\n </datafield>\n <datafield tag="710" ind1=" " ind2=" ">\n <subfield code="g">GAMBIT</subfield>\n </datafield>\n <datafield tag="245" ind1=" " ind2=" ">\n <subfield code="a">GAMBIT : Global And Modular BSM Inference Tool</subfield>\n </datafield>\n <datafield tag="372" ind1=" " ind2=" ">\n <subfield code="9">INSPIRE</subfield>\n <subfield code="a">9.2</subfield>\n </datafield>\n <datafield tag="520" ind1=" " ind2=" ">\n <subfield code="a">GAMBIT is a global fitting code for generic Beyond the Standard Model theories, designed to allow fast and easy definition of new models, observables, likelihoods, scanners and backend physics codes.</subfield>\n </datafield>\n <datafield tag="119" ind1=" " ind2=" ">\n <subfield code="a">GAMBIT</subfield>\n <subfield code="c">GAMBIT</subfield>\n <subfield code="d">GAMBIT</subfield>\n </datafield>\n</record>' deleted_record = LegacyRecordsMirror.from_marcxml(raw_deleted_record) db.session.add(deleted_record) create_records_from_mirror_recids([1775082]) pid = PersistentIdentifier.query.filter_by(pid_value="1775082").one() assert InspireRecord.get_record_by_pid_value("1775082", "exp") assert pid.status == PIDStatus.DELETED
def test_assign_author_to_papers(inspire_app): lit_record = create_record( "lit", data={ "authors": [{ "full_name": "Test Author", "ids": [{ "schema": "INSPIRE BAI", "value": "T.Author.1" }], }] }, ) lit_record_1 = create_record( "lit", data={ "authors": [{ "full_name": "Test Author", "ids": [{ "schema": "INSPIRE BAI", "value": "T.Author.1" }], }] }, ) record = create_record( "aut", data={"ids": [{ "schema": "INSPIRE BAI", "value": "T.Author.1" }]}) lit_record_db = InspireRecord.get_record_by_pid_value( lit_record["control_number"], "lit") lit_record_1_db = InspireRecord.get_record_by_pid_value( lit_record_1["control_number"], "lit") assert lit_record_db["authors"][0]["record"] == record["self"] assert lit_record_1_db["authors"][0]["record"] == record["self"]
def test_get_literature_recids_for_orcid_still_works_if_author_has_no_orcid_id( inspire_app, datadir): data = json.loads((datadir / "1061000.json").read_text()) create_record("aut", data=data) record = InspireRecord.get_record_by_pid_value(1061000, pid_type="aut") record["ids"] = [{ "schema": "INSPIRE BAI", "value": "Maurizio.Martinelli.1" }] record = InspireRecord.create_or_update(record) with pytest.raises(NoResultFound): get_literature_recids_for_orcid("0000-0003-4792-9178")
def test_update_relations_recalculate_citations_with_different_type_of_records_doesnt_throw_an_exception( inspire_app, celery_app_with_context, celery_session_worker): data_cited = faker.record("lit", with_control_number=True) record_cited = InspireRecord.create(data_cited, disable_relations_update=True) db.session.commit() record_cited_control_number = record_cited["control_number"] data_citing = faker.record( "lit", literature_citations=[record_cited_control_number], with_control_number=True, ) record_citing = InspireRecord.create(data_citing, disable_relations_update=True) db.session.commit() records = [ create_record_async("aut"), create_record_async("job"), create_record_async("jou"), create_record_async("exp"), create_record_async("con"), create_record_async("dat"), create_record_async("ins"), ] uuids = [record.id for record in records] + [record_cited.id, record_citing.id] task = update_relations.delay(uuids) results = task.get(timeout=5) uuids = [str(uuid) for uuid in uuids] assert results == uuids result_record_cited = RecordCitations.query.filter_by( cited_id=record_cited.id).one() assert record_citing.id == result_record_cited.citer_id record_cited = InspireRecord.get_record_by_pid_value( record_cited_control_number, "lit") record_cited_citation_count = 1 assert record_cited_citation_count == record_cited.citation_count
def test_update_relations(inspire_app, celery_app_with_context, celery_session_worker): conference_data = faker.record("con", with_control_number=True) conference_record = InspireRecord.create(conference_data) data_cited = faker.record("lit", with_control_number=True) record_cited = InspireRecord.create(data_cited, disable_relations_update=True) db.session.commit() record_cited_control_number = record_cited["control_number"] conference_control_number = conference_record["control_number"] conf_ref = f"http://localhost:8000/api/conferences/{conference_control_number}" data = faker.record( "lit", literature_citations=[record_cited_control_number], with_control_number=True, ) data["publication_info"] = [{"conference_record": {"$ref": conf_ref}}] data["document_type"] = ["conference paper"] record = InspireRecord.create(data, disable_relations_update=True) db.session.commit() uuids = [record_cited.id, record.id] task = update_relations.delay(uuids) task.get(timeout=5) result_record_cited = RecordCitations.query.filter_by( cited_id=record_cited.id).one() assert record.id == result_record_cited.citer_id record_cited = InspireRecord.get_record_by_pid_value( record_cited_control_number, "lit") expected_record_cited_citation_count = 1 assert expected_record_cited_citation_count == record_cited.citation_count conf_paper = ConferenceLiterature.query.filter_by( conference_uuid=conference_record.id).one() assert conf_paper.literature_uuid == record.id
def resolve_conference_record_as_root(self, pub_info_item): conference_record = pub_info_item.get("conference_record") if conference_record is None: return {} _, recid = PidStoreBase.get_pid_from_record_uri( conference_record.get("$ref")) try: conference = InspireRecord.get_record_by_pid_value(pid_value=recid, pid_type="con") except PIDDoesNotExistError: return {} titles = conference.get("titles") if not titles: return {} pub_info_item.update(conference) return pub_info_item
def revert_to_revision(endpoint, pid_value): """Revert given record to given revision""" try: pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint) record = InspireRecord.get_record_by_pid_value(pid_value, pid_type, original_record=True) if not check_permissions_for_private_collection_read_write( record.get("_collections", [])): return jsonify(message="Unauthorized", code=403), 403 revision_id = request.json["revision_id"] record.revert(revision_id) db.session.commit() return jsonify(success=True) except Exception: raise EditorRevertToRevisionError
def test_index_record_deletes_a_deleted_record(inspire_app, clean_celery_session): record_to_delete = create_record_async("lit") record_to_delete_control_number = record_to_delete["control_number"] record_to_delete = InspireRecord.get_record_by_pid_value( record_to_delete_control_number, "lit") record_to_delete.delete() db.session.commit() uuids = [record_to_delete.id] task = index_records.delay(uuids) results = task.get(timeout=5) uuids = [str(uuid) for uuid in uuids] assert results == uuids with pytest.raises(TransportError): InspireSearch.get_record_data_from_es(record_to_delete)
def test_continuous_migration_with_an_invalid_record(app, cache, celery_app_with_context, celery_session_worker): raw_record_citer = ( b"<record>" b' <controlfield tag="001">666</controlfield>' b' <datafield tag="245" ind1=" " ind2=" ">' b' <subfield code="a">This is a citer record</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b' <datafield tag="999" ind1="C" ind2="5">' b' <subfield code="0">667</subfield>' b' <subfield code="h">Achasov, M.N.</subfield>' b' <subfield code="k">snd-2018</subfield>' b' <subfield code="m">(SND Collaboration)</subfield>' b' <subfield code="o">2</subfield>' b' <subfield code="s">Phys.Rev.,D97,012008</subfield>' b' <subfield code="x">' b" [2] M. N. Achasov (SND Collaboration), Phys. Rev. D 97, 012008 (2018)." b" </subfield>" b' <subfield code="y">2018</subfield>' b' <subfield code="z">0</subfield>' b' <subfield code="z">1</subfield>' b" </datafield>" b"</record>") citer_control_number = 666 raw_record_cited = ( b"<record>" b' <controlfield tag="001">667</controlfield>' b' <datafield tag="245" ind1=" " ind2=" ">' b' <subfield code="a">This is a citing record</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b"</record>") cited_control_number = 667 raw_record_invalid = ( b"<record>" b' <controlfield tag="001">668</controlfield>' b' <datafield tag="260" ind1=" " ind2=" ">' b' <subfield code="c">Definitely not a date</subfield>' b" </datafield>" b' <datafield tag="980" ind1=" " ind2=" ">' b' <subfield code="a">HEP</subfield>' b" </datafield>" b"</record>") invalid_control_number = 668 cache.rpush("legacy_records", zlib.compress(raw_record_citer)) cache.rpush("legacy_records", zlib.compress(raw_record_invalid)) cache.rpush("legacy_records", zlib.compress(raw_record_cited)) assert cache.llen("legacy_records") == 3 continuous_migration() # I don't like timeouts, it's the only way to wait for this chain time.sleep(10) record_citer = InspireRecord.get_record_by_pid_value( citer_control_number, "lit") record_cited = InspireRecord.get_record_by_pid_value( cited_control_number, "lit") with pytest.raises(PIDDoesNotExistError): InspireRecord.get_record_by_pid_value(invalid_control_number, "lit") assert record_cited.citation_count == 1 record_citer_es = InspireSearch.get_record_data_from_es(record_citer) result_citer_control_number = record_citer_es["control_number"] assert citer_control_number == result_citer_control_number record_cited_es = InspireSearch.get_record_data_from_es(record_cited) result_cited_control_number = record_cited_es["control_number"] assert cited_control_number == result_cited_control_number with app.test_client() as client: result = client.get( f"/literature/{result_cited_control_number}/citations").json result_citation_count = result["metadata"]["citation_count"] assert 1 == result_citation_count assert cache.llen("legacy_records") == 0
"legacy_name": "GAMBIT", "experiment": { "value": "GAMBIT", "short_name": "GAMBIT" }, "$schema": "https://inspirebeta.net/schemas/records/experiments.json", "_collections": ["Experiments"], } cls = InspireRecord.get_class_for_record(json_record) record = cls.create_or_update(json_record, disable_external_push=True, disable_relations_update=True) pid = PersistentIdentifier.query.filter_by(pid_value="1775082").one() assert record.id assert InspireRecord.get_record_by_pid_value("1775082", "exp") assert pid.status == PIDStatus.DELETED def test_creating_record_with_id_provided_properly_mints_identifiers( inspire_app): record_data = { "$schema": "https://inspirebeta.net/schemas/records/hep.json", "control_number": 1_234_567, "arxiv_eprints": [{ "value": "2105.06728", "categories": ["astro-ph.IM"] }], "_collections": ["Literature"], "document_type": ["article"], "titles": [{