def test_valid_rights(funding, minimal_record):
metadata = minimal_record['metadata']
# NOTE: this is done to get possible load transformations out of the way
metadata = MetadataSchema().load(metadata)
metadata['funding'] = funding
assert metadata == MetadataSchema().load(metadata)
def test_valid_rights(rights, minimal_record, vocabulary_clear):
metadata = minimal_record['metadata']
# NOTE: this is done to get possible load transformations out of the way
metadata = MetadataSchema().load(metadata)
metadata['rights'] = rights
assert metadata == MetadataSchema().load(metadata)
def test_valid_multiple_locations(app, minimal_record, valid_full_location):
metadata = minimal_record['metadata']
# NOTE: this is done to get possible load transformations out of the way
metadata = MetadataSchema().load(metadata)
metadata['locations'] = [valid_full_location, valid_full_location]
assert metadata == MetadataSchema().load(metadata)
def test_metadata_requires_non_empty_creators(
app, minimal_metadata
):
del minimal_metadata["creators"]
assert_raises_messages(
lambda: MetadataSchema().load(minimal_metadata),
{'creators': [
"Missing data for required field."
]}
)
minimal_metadata["creators"] = []
assert_raises_messages(
lambda: MetadataSchema().load(minimal_metadata),
{'creators': [
"Missing data for required field."
]}
)
minimal_metadata["creators"] = None
assert_raises_messages(
lambda: MetadataSchema().load(minimal_metadata),
{'creators': [
"Field may not be null."
]}
)
def test_valid_rights(app, references, minimal_record):
metadata = minimal_record['metadata']
# NOTE: this is done to get possible load transformations out of the way
metadata = MetadataSchema().load(metadata)
metadata['references'] = references
assert metadata == MetadataSchema().load(metadata)
def test_valid_single_location(app, minimal_record, valid_full_location):
metadata = minimal_record['metadata']
# NOTE: this is done to get possible load transformations out of the way
metadata = MetadataSchema().load(metadata)
metadata['locations'] = {"features": [valid_full_location]}
assert metadata == MetadataSchema().load(metadata)
def test_metadata_schema(
vocabulary_clear, full_record, minimal_record):
"""Test metadata schema."""
# Test full attributes
data = MetadataSchema().load(full_record)
assert data == full_record
# Test minimal attributes
data = MetadataSchema().load(minimal_record)
assert data == minimal_record
def test_invalid_no_resource_type(minimal_metadata, vocabulary_clear):
minimal_metadata["resource_type"] = {}
assert_raises_messages(
lambda: MetadataSchema().load(minimal_metadata),
{"resource_type": ["Missing data for required field."]})
del minimal_metadata["resource_type"]
assert_raises_messages(
lambda: MetadataSchema().load(minimal_metadata),
{"resource_type": ["Missing data for required field."]})
def test_invalid_subtype(custom_config, minimal_metadata, vocabulary_clear):
minimal_metadata["resource_type"] = {
"type": "my_image",
"subtype": "invalid"
}
assert_raises_messages(lambda: MetadataSchema().load(minimal_metadata),
{"resource_type": [_("Invalid value.")]})
def test_valid_no_subtype(minimal_metadata, vocabulary_clear):
expected_metadata = deepcopy(minimal_metadata)
expected_metadata["creators"][0]["person_or_org"]["name"] = "Brown, Troy"
expected_metadata["resource_type"] = minimal_metadata["resource_type"] = {
"type": "poster"
}
assert expected_metadata == MetadataSchema().load(minimal_metadata)
def test_custom_previous_types_now_invalid(custom_config, minimal_metadata,
vocabulary_clear):
minimal_metadata["resource_type"] = {
"type": "image",
"subtype": "image-photo"
}
assert_raises_messages(lambda: MetadataSchema().load(minimal_metadata),
{"resource_type": [_("Invalid value.")]})
def test_custom_valid_full(custom_config, minimal_metadata, vocabulary_clear):
expected_metadata = deepcopy(minimal_metadata)
expected_metadata["creators"][0]["person_or_org"]["name"] = "Brown, Troy"
expected_metadata["resource_type"] = minimal_metadata["resource_type"] = {
"type": "my_image",
"subtype": "my_photo"
}
assert expected_metadata == MetadataSchema().load(minimal_metadata)
def test_invalid_type(custom_config, minimal_metadata, vocabulary_clear):
# doubles as a test of custom config
minimal_metadata["resource_type"] = {
"type": "invalid",
"subtype": "image-photo"
}
assert_raises_messages(lambda: MetadataSchema().load(minimal_metadata),
{"resource_type": [_("Invalid value.")]})
def test_valid_no_subtype(minimal_metadata):
# whether id represents a resource type with or without subtype should
# not matter
expected_metadata = deepcopy(minimal_metadata)
expected_metadata["creators"][0]["person_or_org"]["name"] = "Brown, Troy"
expected_metadata["resource_type"] = minimal_metadata["resource_type"] = {
"id": "dataset"
}
assert expected_metadata == MetadataSchema().load(minimal_metadata)
def test_valid_multiple_identifiers(app, minimal_record):
metadata = minimal_record['metadata']
metadata['identifiers'] = [{
"identifier": "10.5281/rdm.9999999",
"scheme": "doi"
}, {
"identifier": "ark:/123/456",
"scheme": "ark"
}]
data = MetadataSchema().load(metadata)
assert data['identifiers'] == metadata['identifiers']
def test_dates_in_metadata_schema(
minimal_metadata, expected_minimal_metadata, vocabulary_clear):
minimal_metadata["dates"] = expected_minimal_metadata["dates"] = [{
"date": "1939/1945",
"type": {"id": "other"},
"description": "A date"
}]
metadata = MetadataSchema().load(minimal_metadata)
assert expected_minimal_metadata == metadata
def test_valid_duplicate_type(app, minimal_record):
# NOTE: Duplicates are accepted, there is no de-duplication
metadata = minimal_record['metadata']
metadata['identifiers'] = [{
"identifier": "10.5281/zenodo.9999999",
"scheme": "doi"
}, {
"identifier": "10.5281/zenodo.0000000",
"scheme": "doi"
}]
data = MetadataSchema().load(metadata)
assert data['identifiers'] == metadata['identifiers']
def test_invalid_related_identifiers(app, minimal_record):
metadata = minimal_record['metadata']
metadata['related_identifiers'] = {
"identifier": "10.5281/rdm.9999988",
"scheme": "doi",
"relation_type": {"id": "requires"},
"resource_type": {
"id": "image-photo"
}
}
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_invalid_duplicate_scheme(app, minimal_record):
# NOTE: Duplicates are accepted, there is no de-duplication
metadata = minimal_record['metadata']
metadata['identifiers'] = [{
"identifier": "10.5281/rdm.9999999",
"scheme": "doi"
}, {
"identifier": "10.5281/rdm.0000000",
"scheme": "doi"
}]
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
metadata['identifiers'] = [{
"identifier": "10.5281/rdm.9999999",
"scheme": "doi"
}, {
"identifier": "10.5281/rdm.0000000"
}]
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_invalid_duplicated_related_identifiers(app, minimal_record):
metadata = minimal_record['metadata']
metadata['related_identifiers'] = [{
"identifier": "10.5281/zenodo.9999988",
"scheme": "doi",
"relation_type": "requires"
}, {
"identifier": "10.5281/zenodo.9999988",
"scheme": "doi",
"relation_type": "requires"
}]
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_valid_related_identifiers_in_schema(app, minimal_record):
metadata = minimal_record['metadata']
metadata['related_identifiers'] = [{
"identifier": "10.5281/zenodo.9999988",
"scheme": "doi",
"relation_type": "requires",
"resource_type": {
"id": "image-photo"
}
}, {
"identifier": "10.5281/zenodo.9999977",
"scheme": "doi",
"relation_type": "requires"
}]
data = MetadataSchema().load(metadata)['related_identifiers']
assert metadata['related_identifiers'] == data
def test_invalid_no_list_languages(app, minimal_record):
metadata = minimal_record['metadata']
metadata['languages'] = {"id": "eng"}
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_invalid_code_languages(app, minimal_record):
metadata = minimal_record['metadata']
metadata['languages'] = ["inv"]
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_invalid_no_list_location(app, minimal_record, valid_full_location):
metadata = minimal_record['metadata']
metadata['locations'] = {"features": valid_full_location}
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_valid_languages(app, minimal_record):
metadata = minimal_record['metadata']
metadata['languages'] = [{"id": "dan"}, {"id": "eng"}]
data = MetadataSchema().load(metadata)
assert data['languages'] == metadata['languages']
def test_valid_size(size, app, minimal_record, vocabulary_clear):
metadata = minimal_record['metadata']
metadata['sizes'] = size
data = MetadataSchema().load(metadata)
assert data['sizes'] == metadata['sizes']
def test_invalid_size(size, app, minimal_record, vocabulary_clear):
metadata = minimal_record['metadata']
metadata['sizes'] = size
with pytest.raises(ValidationError):
data = MetadataSchema().load(metadata)
def test_valid_empty_list(app, minimal_record):
metadata = minimal_record['metadata']
metadata['identifiers'] = []
data = MetadataSchema().load(metadata)
assert data['identifiers'] == metadata['identifiers']
def test_minimal_metadata_schema(
vocabulary_clear, minimal_metadata, expected_minimal_metadata):
metadata = MetadataSchema().load(minimal_metadata)
assert expected_minimal_metadata == metadata
def test_extensions(app, minimal_record):
"""Test metadata extensions schema."""
# Setup metadata extensions
RDM_RECORDS_METADATA_NAMESPACES = {
'dwc': {
'@context': 'https://example.com/dwc/terms'
},
'nubiomed': {
'@context': 'https://example.com/nubiomed/terms'
}
}
RDM_RECORDS_METADATA_EXTENSIONS = {
'dwc:family': {
'elasticsearch': 'keyword',
'marshmallow': SanitizedUnicode(required=True)
},
'dwc:behavior': {
'elasticsearch': 'text',
'marshmallow': SanitizedUnicode()
},
'nubiomed:number_in_sequence': {
'elasticsearch': 'long',
'marshmallow': Integer()
},
'nubiomed:scientific_sequence': {
'elasticsearch': 'long',
'marshmallow': List(Integer())
},
'nubiomed:original_presentation_date': {
'elasticsearch': 'date',
'marshmallow': ISODateString()
},
'nubiomed:right_or_wrong': {
'elasticsearch': 'boolean',
'marshmallow': Bool()
}
}
orig_metadata_extensions = (
app.extensions['invenio-rdm-records'].metadata_extensions
)
app.extensions['invenio-rdm-records'].metadata_extensions = (
MetadataExtensions(
RDM_RECORDS_METADATA_NAMESPACES,
RDM_RECORDS_METADATA_EXTENSIONS
)
)
# Minimal if not absent
valid_minimal = {
'dwc:family': 'Felidae'
}
minimal_record['extensions'] = valid_minimal
data = MetadataSchema().load(minimal_record)
assert valid_minimal == data.get('extensions')
# Full
valid_full = {
'dwc:family': 'Felidae',
'dwc:behavior': 'Plays with yarn, sleeps in cardboard box.',
'nubiomed:number_in_sequence': 3,
'nubiomed:scientific_sequence': [1, 1, 2, 3, 5, 8],
'nubiomed:original_presentation_date': '2019-02-14',
'nubiomed:right_or_wrong': True,
}
minimal_record['extensions'] = valid_full
data = MetadataSchema().load(minimal_record)
assert valid_full == data.get('extensions')
# Invalid
invalid_number_in_sequence = {
'dwc:family': 'Felidae',
'nubiomed:scientific_sequence': [1, 'l', 2, 3, 5, 8],
}
minimal_record['extensions'] = invalid_number_in_sequence
with pytest.raises(ValidationError):
data = MetadataSchema().load(minimal_record)
app.extensions['invenio-rdm-records'].metadata_extensions = (
orig_metadata_extensions
)