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": [{
