def test_uses_first_schema_that_returns_true_for_condition_that_uses_data():
class BaseMetadataSchema(Schema):
metadata = fields.Method("get_metadata")
class Schema1(BaseMetadataSchema):
def get_metadata(self, data):
return {"field1": data["metadata"]["field1"]}
class Schema2(BaseMetadataSchema):
def get_metadata(self, data):
return {"field2": data["metadata"]["field2"]}
class Schema3(BaseMetadataSchema):
def get_metadata(self, data):
return {"field3": data["metadata"]["field3"]}
data = {
"field1": "value1",
"field2": "value2",
"field3": "value3",
"types": [2, 3]
}
serializer = ConditionalMultiSchemaJSONSerializer([
(lambda data: 1 in data["metadata"]["types"], Schema1),
(lambda data: 2 in data["metadata"]["types"], Schema2),
(lambda data: 3 in data["metadata"]["types"], Schema3),
])
serialized = json.loads(
serializer.serialize(
PersistentIdentifier(pid_type="recid", pid_value="1"),
InspireRecord(data)))
assert serialized["metadata"] == {"field2": "value2"}
def test_returns_arxiv_eprints_from_the_resolved_record(
mock_get_linked_records_in_field):
mock_get_linked_records_in_field.return_value = [
InspireRecord({
"control_number":
123,
"arxiv_eprints": [{
"value": "1606.09129",
"categories": "hep"
}],
})
]
hep_schema = load_schema("hep")
subschema = hep_schema["properties"]["references"]
schema = ReferenceItemSchemaV1()
dump = {"record": {"$ref": "http://localhost:5000/api/literature/123"}}
assert validate([dump], subschema) is None
expected = {
"control_number": 123,
"arxiv_eprint": [{
"value": "1606.09129"
}]
}
result = schema.dumps(dump).data
assert expected == json.loads(result)
def index_after_commit(sender, changes):
"""Index a record in ES after it was committed to the DB.
This cannot happen in an ``after_record_commit`` receiver from Invenio-Records
because, despite the name, at that point we are not yet sure whether the record
has been really committed to the DB.
"""
for model_instance, change in changes:
if isinstance(model_instance, RecordMetadata):
if change in ("insert", "update", "delete"):
LOGGER.debug(
"Record commited, indexing.",
change=change,
uuid=str(model_instance.id),
)
force_delete = "delete" == change
InspireRecord(
model_instance.json,
model=model_instance).index(force_delete=force_delete)
if "new_record" in model_instance.json:
redirect_references_to_merged_record.delay(
str(model_instance.id))
if (PidStoreBase.get_pid_type_from_schema(
model_instance.json["$schema"]) == "lit"
and "documents" in model_instance.json and
current_app.config["FEATURE_FLAG_ENABLE_FULLTEXT"]):
index_fulltext.delay(str(model_instance.id),
model_instance.version_id)
def index_after_commit(sender, changes):
"""Index a record in ES after it was committed to the DB.
This cannot happen in an ``after_record_commit`` receiver from Invenio-Records
because, despite the name, at that point we are not yet sure whether the record
has been really committed to the DB.
"""
for model_instance, change in changes:
if isinstance(model_instance, RecordMetadata):
if change in ("insert", "update", "delete"):
LOGGER.debug(
f"Record commited, indexing.",
change=change,
uuid=str(model_instance.id),
)
force_delete = "delete" == change
InspireRecord(
model_instance.json,
model=model_instance).index(force_delete=force_delete)
if (change != "delete" and current_app.
config["FEATURE_FLAG_ENABLE_AUTHOR_DISAMBIGUATION"]):
disambiguate_authors.delay(str(model_instance.id))
if "new_record" in model_instance.json:
redirect_references_to_merged_record.delay(
str(model_instance.id))
def test_returns_no_misc_if_titles_persent_in_the_resolved_record(
mock_get_linked_records_in_field,
):
mock_get_linked_records_in_field.return_value = [
InspireRecord(
{
"control_number": 123,
"titles": [
{
"source": "arXiv",
"title": "Theoretical limit of residual amplitude modulation in electro-optic modulators", # noqa
},
{
"source": "arXiv",
"title": "Fundamental level of residual amplitude modulation in phase modulation processes", # noqa
},
],
}
)
]
hep_schema = load_schema("hep")
subschema = hep_schema["properties"]["references"]
schema = ReferenceItemSchemaV1()
dump = {
"record": {"$ref": "http://localhost:5000/api/literature/123"},
"reference": {"label": "123", "misc": ["A misc"]},
}
assert validate([dump], subschema) is None
result = schema.dumps(dump).data
assert "misc" not in orjson.loads(result)
def test_get_linked_records_in_field_empty(inspire_app):
expected_result_len = 0
expected_result = []
record = InspireRecord({})
result = record.get_linked_records_from_field("references.record")
result = list(result)
assert expected_result_len == len(result)
assert expected_result == result
def test_get_linked_records_in_field_empty(base_app, db, es,
create_record_factory):
expected_result_len = 0
expected_result = []
record = InspireRecord({})
result = record.get_linked_records_from_field("references.record")
result = list(result)
assert expected_result_len == len(result)
assert expected_result == result
def create_from_kwargs(cls,
index_name="",
disable_persistent_identifier=False,
**kwargs):
instance = cls()
updated_kwargs = copy.deepcopy(kwargs)
if not kwargs.pop("id", None):
updated_kwargs["id"] = uuid.uuid4()
json_ = copy.deepcopy(cls.JSON_SKELETON)
json_.update(kwargs.pop("json", {}))
if kwargs.get("pid_type", "lit") == "lit" and "titles" not in json_:
json_.update({"titles": [{"title": generate_random_string(60)}]})
if "control_number" not in json_:
json_["control_number"] = get_next_free_recid()
else:
reserve_recid(json_["control_number"])
updated_kwargs["json"] = json_
instance.record_metadata = super(
TestRecordMetadata, cls).create_from_kwargs(updated_kwargs)
if index_name:
instance.es_index_result = es.index(
index=index_name,
body=instance.record_metadata.json,
params={})
instance.es_refresh_result = es.indices.refresh(index_name)
if not disable_persistent_identifier:
instance.persistent_identifier = (
TestPersistentIdentifier.create_from_kwargs(
object_uuid=instance.record_metadata.id,
pid_value=instance.record_metadata.json.get(
"control_number"),
**kwargs).persistent_identifier)
instance.inspire_record = InspireRecord(instance.record_metadata.json,
model=RecordMetadata)
return instance
def test_returns_dois_from_the_resolved_record(mock_get_linked_records_in_field):
mock_get_linked_records_in_field.return_value = [
InspireRecord(
{"control_number": 123, "dois": [{"value": "10.1103/PhysRevD.94.054021"}]}
)
]
hep_schema = load_schema("hep")
subschema = hep_schema["properties"]["references"]
schema = ReferenceItemSchemaV1()
dump = {"record": {"$ref": "http://localhost:5000/api/literature/123"}}
assert validate([dump], subschema) is None
expected = {
"control_number": 123,
"dois": [{"value": "10.1103/PhysRevD.94.054021"}],
}
result = schema.dumps(dump).data
assert expected == orjson.loads(result)
def index_after_commit(sender, changes):
"""Index a record in ES after it was committed to the DB.
This cannot happen in an ``after_record_commit`` receiver from Invenio-Records
because, despite the name, at that point we are not yet sure whether the record
has been really committed to the DB.
"""
for model_instance, change in changes:
if isinstance(model_instance, RecordMetadata):
if change in ("insert", "update", "delete"):
LOGGER.debug(
f"Record commited, indexing.",
change=change,
uuid=str(model_instance.id),
)
force_delete = "delete" == change
InspireRecord(
model_instance.json,
model=model_instance).index(force_delete=force_delete)
def test_first_conditionless_schema_if_others_do_not_return_true():
class BaseMetadataSchema(Schema):
metadata = fields.Method("get_metadata")
class Schema1(BaseMetadataSchema):
def get_metadata(self, data):
return {"field1": data["metadata"]["field1"]}
class Schema2(BaseMetadataSchema):
def get_metadata(self, data):
return {"field2": data["metadata"]["field2"]}
data = {"field1": "value1", "field2": "value2"}
serializer = ConditionalMultiSchemaJSONSerializer([(lambda _: False,
Schema1),
(None, Schema2)])
serialized = json.loads(
serializer.serialize(
PersistentIdentifier(pid_type="recid", pid_value="1"),
InspireRecord(data)))
assert serialized["metadata"] == {"field2": "value2"}
def test_record_throws_exception_when_serializer_is_not_set(inspire_app):
record_metadata = create_record_factory("lit")
record = InspireRecord(record_metadata.json)
with pytest.raises(MissingSerializerError):
record.get_enhanced_es_data()
