def test_literature_create_with_mutliple_pids(base_app, db, create_pidstore):
doi_value = faker.doi()
arxiv_value = faker.arxiv()
data = {"arxiv_eprints": [{"value": arxiv_value}], "dois": [{"value": doi_value}]}
data = faker.record("lit", with_control_number=True, data=data)
expected_pids_len = 3
expected_pid_lit_value = str(data["control_number"])
expected_pid_arxiv_value = arxiv_value
expected_pid_doi_value = doi_value
record = LiteratureRecord.create(data)
record_lit_pid = PersistentIdentifier.query.filter_by(pid_type="lit").one()
record_arxiv_pid = PersistentIdentifier.query.filter_by(pid_type="arxiv").one()
record_doi_pid = PersistentIdentifier.query.filter_by(pid_type="doi").one()
record_total_pids = PersistentIdentifier.query.filter_by(
object_uuid=record.id
).count()
assert expected_pids_len == record_total_pids
assert expected_pid_lit_value == record_lit_pid.pid_value
assert expected_pid_arxiv_value == record_arxiv_pid.pid_value
assert expected_pid_doi_value == record_doi_pid.pid_value
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_literature_create_with_invalid_data_and_mutliple_pids(
base_app, db, create_pidstore
):
doi_value = faker.doi()
arxiv_value = faker.arxiv()
data = {"arxiv_eprints": [{"value": arxiv_value}], "dois": [{"value": doi_value}]}
data = faker.record("lit", with_control_number=True, data=data)
data["invalid_key"] = "should throw an error"
pid_lit_value = str(data["control_number"])
pid_arxiv_value = arxiv_value
pid_doi_value = doi_value
with pytest.raises(ValidationError):
LiteratureRecord.create(data)
record_lit_pid = PersistentIdentifier.query.filter_by(
pid_value=pid_lit_value
).one_or_none()
record_arxiv_pid = PersistentIdentifier.query.filter_by(
pid_value=pid_arxiv_value
).one_or_none()
record_doi_pid = PersistentIdentifier.query.filter_by(
pid_value=pid_doi_value
).one_or_none()
assert record_lit_pid is None
assert record_arxiv_pid is None
assert record_doi_pid is None
def test_literature_on_delete_through_metadata_update(base_app, db, es_clear):
doi_value = faker.doi()
arxiv_value = faker.arxiv()
data = {"arxiv_eprints": [{"value": arxiv_value}], "dois": [{"value": doi_value}]}
data = faker.record("lit", data=data, with_control_number=True)
record = LiteratureRecord.create(data)
expected_pid_lit_value = str(data["control_number"])
expected_pid_arxiv_value = arxiv_value
expected_pid_doi_value = doi_value
record_lit_pid = PersistentIdentifier.query.filter_by(pid_type="lit").one()
record_arxiv_pid = PersistentIdentifier.query.filter_by(pid_type="arxiv").one()
record_doi_pid = PersistentIdentifier.query.filter_by(pid_type="doi").one()
assert expected_pid_lit_value == record_lit_pid.pid_value
assert expected_pid_arxiv_value == record_arxiv_pid.pid_value
assert expected_pid_doi_value == record_doi_pid.pid_value
record["deleted"] = True
record.update(dict(record))
record_lit_pid = PersistentIdentifier.query.filter_by(pid_type="lit").one()
record_arxiv_pid = PersistentIdentifier.query.filter_by(
pid_type="arxiv"
).one_or_none()
record_doi_pid = PersistentIdentifier.query.filter_by(pid_type="doi").one_or_none()
assert None == record_arxiv_pid
assert None == record_doi_pid
assert PIDStatus.DELETED == record_lit_pid.status
def test_import_article_doi_already_in_inspire(base_app, db, es):
doi_value = faker.doi()
data = {"dois": [{"value": doi_value}]}
data = faker.record("lit", with_control_number=True, data=data)
LiteratureRecord.create(data)
with pytest.raises(ExistingArticleError):
import_article(doi_value)
def test_dump_doi():
doi = faker.doi()
data = {**DEFAULT_DATA_TO_DUMP, "dois": [{"value": doi}]}
record = faker.record("lit", data=data)
result = Literature().dump(record).data
expected = {**DEFAULT_DUMP, "doi": doi}
assert result == expected
def test_mitner_dois_missing_schema(inspire_app):
doi_value = faker.doi()
data = {"dois": [{"value": doi_value}]}
record = create_record_factory("lit", data=data)
record_data = record.json
record_id = record.id
record_data.pop("$schema")
with pytest.raises(MissingSchema):
DoiMinter.mint(record_id, record_data)
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_minter_dois(inspire_app):
doi_value_1 = faker.doi()
doi_value_2 = faker.doi()
data = {"dois": [{"value": doi_value_1}, {"value": doi_value_2}]}
record = create_record_factory("lit", data=data, with_validation=True)
data = record.json
DoiMinter.mint(record.id, data)
expected_pids_len = 2
epxected_pids_values = [doi_value_1, doi_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="doi").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_literature_create_with_dois(base_app, db, es):
doi_value = faker.doi()
data = {"dois": [{"value": doi_value}]}
data = faker.record("lit", data=data)
record = LiteratureRecord.create(data)
record_db = RecordMetadata.query.filter_by(id=record.id).one()
assert record == record_db.json
expected_doi_pid_value = doi_value
expected_doi_pid_type = "doi"
expected_doi_pid_provider = "external"
record_pid_doi = PersistentIdentifier.query.filter_by(
pid_type="doi", object_uuid=record.id
).one()
assert record.model.id == record_pid_doi.object_uuid
assert expected_doi_pid_value == record_pid_doi.pid_value
assert expected_doi_pid_type == record_pid_doi.pid_type
assert expected_doi_pid_provider == record_pid_doi.pid_provider
