Пример #1
0
def test_contributor_person_valid_minimal(vocabulary_clear):
    valid_minimal_given_name = {
        "person_or_org": {
            "given_name": "Julio",
            "type": "personal",
        },
        "role": "rightsholder"
    }
    expected = {
        "person_or_org": {
            "given_name": "Julio",
            "name": "Julio",
            "type": "personal",
        },
        "role": "rightsholder",
    }
    assert expected == ContributorSchema().load(valid_minimal_given_name)

    valid_minimal_family_name = {
        "person_or_org": {
            "family_name": "Cesar",
            "type": "personal",
        },
        "role": "rightsholder"
    }
    expected = {
        "person_or_org": {
            "family_name": "Cesar",
            "name": "Cesar",
            "type": "personal",
        },
        "role": "rightsholder",
    }
    assert expected == ContributorSchema().load(valid_minimal_family_name)
Пример #2
0
def test_contributor_person_valid_full(vocabulary_clear):
    valid_full = {
        "affiliations": [{
            "id": "test"
        }],
        "person_or_org": {
            "family_name":
            "Cesar",
            "given_name":
            "Julio",
            "identifiers": [{
                "scheme": "orcid",
                "identifier": "0000-0002-1825-0097",
            }],
            "type":
            "personal",
        },
        "role": {
            "id": "rightsholder"
        }
    }

    loaded = ContributorSchema().load(valid_full)
    valid_full["person_or_org"]["name"] = "Cesar, Julio"

    assert loaded == valid_full
def test_contributor_valid_minimal(vocabulary_clear):
    valid_minimal = {
        "name": "Julio Cesar",
        "type": "personal",
        "role": "rightsholder"
    }
    assert valid_minimal == ContributorSchema().load(valid_minimal)
def test_contributor_invalid_no_role(vocabulary_clear):
    invalid_no_role = {
        "name": "Julio Cesar",
        "type": "personal",
        "given_name": "Julio",
        "family_name": "Cesar",
        "identifiers": {
            "orcid": "0000-0002-1825-0097",
        },
    }

    assert_raises_messages(lambda: ContributorSchema().load(invalid_no_role),
                           {'role': ['Missing data for required field.']})
def test_contributor_person_invalid_no_family_name_nor_given_name(
        vocabulary_clear):
    invalid_no_family_name_nor_given_name = {
        "type": "personal",
        "identifiers": {
            "orcid": "0000-0002-1825-0097",
        },
        "role": "rightsholder"
    }

    assert_raises_messages(
        lambda: ContributorSchema().load(
            invalid_no_family_name_nor_given_name), {
                'family_name': ['One name must be filled.'],
                'given_name': ['One name must be filled.'],
            })
def test_contributor_invalid_role(custom_config, vocabulary_clear):
    # Doubles as a test of custom roles
    invalid_role = {
        "name": "Julio Cesar",
        "type": "personal",
        "given_name": "Julio",
        "family_name": "Cesar",
        "identifiers": {
            "orcid": "0000-0002-1825-0097",
        },
        "role": "Invalid"
    }

    assert_raises_messages(lambda: ContributorSchema().load(invalid_role), {
        'role':
        ["Invalid value. Choose one of ['DataCollector', 'Librarian']."]
    })
def test_contributor_person_valid_minimal(app):
    valid_minimal_family_name = {
        "person_or_org": {
            "family_name": "Cesar",
            "type": "personal",
        },
        "role": {"id": "rightsholder"}
    }
    expected = {
        "person_or_org": {
            "family_name": "Cesar",
            "name": "Cesar",
            "type": "personal",
        },
        "role": {"id": "rightsholder"},
    }
    assert expected == ContributorSchema().load(valid_minimal_family_name)
def test_contributor_valid_full(vocabulary_clear):
    valid_full = {
        "name": "Julio Cesar",
        "type": "personal",
        "given_name": "Julio",
        "family_name": "Cesar",
        "identifiers": {
            "orcid": "0000-0002-1825-0097",
        },
        "affiliations": [{
            "name": "Entity One",
            "identifiers": {
                "ror": "03yrm5c26"
            }
        }],
        "role": "rightsholder"
    }
    assert valid_full == ContributorSchema().load(valid_full)
def test_contributor_invalid_role(app):
    # Doubles as a test of custom roles
    invalid_role = {
        "person_or_org": {
            "name": "Julio Cesar",
            "type": "personal",
            "given_name": "Julio",
            "family_name": "Cesar",
            "identifiers": [{
                "scheme": "orcid",
                "identifier": "0000-0002-1825-0097",
            }],
        },
        "role": "Invalid"
    }

    assert_raises_messages(
        lambda: ContributorSchema().load(invalid_role),
        {'role': {'_schema': ['Invalid input type.']}}
    )
def test_contributor_person_invalid_no_family_name_nor_given_name(
    app
):
    invalid_no_family_name_nor_given_name = {
        "person_or_org": {
            "type": "personal",
            "identifiers": [{
                "scheme": "orcid",
                "identifier": "0000-0002-1825-0097",
            }],
        },
        "role": {"id": "rightsholder"}
    }

    assert_raises_messages(
        lambda: ContributorSchema().load(
            invalid_no_family_name_nor_given_name
        ),
        {"person_or_org": {
            'family_name': ["Family name must be filled."]
        }}
    )