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 )