def _normalize(a_value):
schema = load_schema('elements/arxiv_categories')
valid_arxiv_categories = schema['enum']
for category in valid_arxiv_categories:
if a_value.lower() == category.lower():
return category
schema = load_schema('elements/inspire_field')
valid_inspire_categories = schema['properties']['term']['enum']
for category in valid_inspire_categories:
if a_value.lower() == category.lower():
return category
field_codes_to_inspire_categories = {
'a': 'Astrophysics',
'b': 'Accelerators',
'c': 'Computing',
'e': 'Experiment-HEP',
'g': 'Gravitation and Cosmology',
'i': 'Instrumentation',
'l': 'Lattice',
'm': 'Math and Math Physics',
'n': 'Theory-Nucl',
'o': 'Other',
'p': 'Phenomenology-HEP',
'q': 'General Physics',
't': 'Theory-HEP',
'x': 'Experiment-Nucl',
}
return field_codes_to_inspire_categories.get(a_value.lower())
def __init__(self, *args, **kwargs):
"""Constructor."""
super(LiteratureForm, self).__init__(*args, **kwargs)
inspire_categories_schema = load_schema('elements/inspire_field.json')
categories = inspire_categories_schema['properties']['term']['enum']
self.subject.choices = [(val, val) for val in categories]
degree_type_schema = load_schema('elements/degree_type.json')
degree_choices = [
(val, val.capitalize()) if val != 'phd' else ('phd', 'PhD')
for val in degree_type_schema['enum']
]
degree_choices.sort(key=lambda x: x[1])
self.degree_type.choices = degree_choices
def test_languages_from_041__a_handles_multiple_languages_in_one_a():
schema = load_schema('hep')
subschema = schema['properties']['languages']
snippet = (
'<datafield tag="041" ind1=" " ind2=" ">'
' <subfield code="a">Russian / English</subfield>'
'</datafield>'
) # record/116959
expected = [
'ru',
'en',
]
result = hep.do(create_record(snippet))
assert validate(result['languages'], subschema) is None
assert expected == result['languages']
expected = [
{'a': 'russian'},
{'a': 'english'},
]
result = hep2marc.do(result)
assert expected == result['041']
def test_languages_from_double_041__a():
schema = load_schema('hep')
subschema = schema['properties']['languages']
snippet = (
'<record>'
' <datafield tag="041" ind1=" " ind2=" ">'
' <subfield code="a">French</subfield>'
' </datafield>'
' <datafield tag="041" ind1=" " ind2=" ">'
' <subfield code="a">German</subfield>'
' </datafield>'
'</record>'
) # record/1231408
expected = [
'fr',
'de',
]
result = hep.do(create_record(snippet))
assert validate(result['languages'], subschema) is None
assert expected == result['languages']
expected = [
{'a': 'french'},
{'a': 'german'},
]
result = hep2marc.do(result)
assert expected == result['041']
def test_isbns_from_020__a_b_normalizes_online():
schema = load_schema('hep')
subschema = schema['properties']['isbns']
snippet = (
'<datafield tag="020" ind1=" " ind2=" ">'
' <subfield code="a">978-94-024-0999-4</subfield>'
' <subfield code="b">Online</subfield>'
'</datafield>'
) # record/1504286
expected = [
{
'value': '9789402409994',
'medium': 'online',
},
]
result = hep.do(create_record(snippet))
assert validate(result['isbns'], subschema) is None
assert expected == result['isbns']
expected = [
{
'a': '9789402409994',
'b': 'online',
},
]
result = hep2marc.do(result)
assert expected == result['020']
def test_arxiv_eprints_from_037__a_c_9():
schema = load_schema('hep')
subschema = schema['properties']['arxiv_eprints']
snippet = (
'<datafield tag="037" ind1=" " ind2=" ">'
' <subfield code="9">arXiv</subfield>'
' <subfield code="a">arXiv:1505.01843</subfield>'
' <subfield code="c">hep-ph</subfield>'
'</datafield>'
) # record/1368891
expected = [
{
'categories': [
'hep-ph',
],
'value': '1505.01843',
},
]
result = hep.do(create_record(snippet))
assert validate(result['arxiv_eprints'], subschema) is None
assert expected == result['arxiv_eprints']
expected = [
{
'9': 'arXiv',
'a': 'arXiv:1505.01843',
'c': 'hep-ph',
},
]
result = hep2marc.do(result)
assert expected == result['037']
def test_ids_from_035__a_9_with_cern():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">CERN</subfield>'
' <subfield code="a">CERN-622961</subfield>'
'</datafield>'
) # record/1064570/export/xme
expected = [
{
'schema': 'CERN',
'value': 'CERN-622961',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'CERN',
'a': 'CERN-622961'
}
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_9_with_wikipedia():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">Wikipedia</subfield>'
' <subfield code="a">Guido_Tonelli</subfield>'
'</datafield>'
) # record/985898/export/xme
expected = [
{
'schema': 'WIKIPEDIA',
'value': 'Guido_Tonelli',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'WIKIPEDIA',
'a': 'Guido_Tonelli',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_external_system_identifiers_from_035__z_9_handles_cernkey():
schema = load_schema('hep')
subschema = schema['properties']['external_system_identifiers']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">CERNKEY</subfield>'
' <subfield code="z">0263439</subfield>'
'</datafield>'
) # record/451647
expected = [
{
'schema': 'CERNKEY',
'value': '0263439',
},
]
result = hep.do(create_record(snippet))
assert validate(result['external_system_identifiers'], subschema) is None
assert expected == result['external_system_identifiers']
expected = [
{
'9': 'CERNKEY',
'z': '0263439',
},
]
result = hep2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_9_with_desy():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="a">DESY-1001805</subfield>'
' <subfield code="9">DESY</subfield>'
'</datafield>'
) # record/993224/export/xme
expected = [
{
'schema': 'DESY',
'value': 'DESY-1001805',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'DESY',
'a': 'DESY-1001805',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_external_system_numbers_from_035__a_d_h_m_9():
schema = load_schema('hep')
subschema = schema['properties']['external_system_identifiers']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">http://cds.cern.ch/oai2d</subfield>'
' <subfield code="a">oai:cds.cern.ch:325030</subfield>'
' <subfield code="d">2015-06-05T13:24:42Z</subfield>'
' <subfield code="h">2015-11-09T16:22:48Z</subfield>'
' <subfield code="m">marcxml</subfield>'
'</datafield>'
) # record/1403324
expected = [
{
'value': 'oai:cds.cern.ch:325030',
'schema': 'http://cds.cern.ch/oai2d',
}
]
result = hep.do(create_record(snippet))
assert validate(result['external_system_identifiers'], subschema) is None
assert expected == result['external_system_identifiers']
expected = [
{
'9': 'http://cds.cern.ch/oai2d',
'a': 'oai:cds.cern.ch:325030',
},
]
result = hep2marc.do(result)
assert expected == result['035']
def test_dois_from_0247_a_2():
schema = load_schema('hep')
subschema = schema['properties']['dois']
snippet = (
'<datafield tag="024" ind1="7" ind2=" ">'
' <subfield code="2">DOI</subfield>'
' <subfield code="a">10.1088/0264-9381/31/24/245004</subfield>'
'</datafield>'
) # record/1302395
expected = [
{'value': '10.1088/0264-9381/31/24/245004'},
]
result = hep.do(create_record(snippet))
assert validate(result['dois'], subschema) is None
assert expected == result['dois']
expected = [
{
'a': '10.1088/0264-9381/31/24/245004',
'2': 'DOI',
},
]
result = hep2marc.do(result)
assert expected == result['0247']
def test_texkeys_from_035__a_9():
schema = load_schema('hep')
subschema = schema['properties']['texkeys']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">INSPIRETeX</subfield>'
' <subfield code="a">Hagedorn:1963hdh</subfield>'
'</datafield>'
) # record/1403324
expected = [
'Hagedorn:1963hdh',
]
result = hep.do(create_record(snippet))
assert validate(result['texkeys'], subschema) is None
assert expected == result['texkeys']
expected = [
{
'9': 'INSPIRETeX',
'a': 'Hagedorn:1963hdh',
}
]
result = hep2marc.do(result)
assert expected == result['035']
def test_isbns_from_020__a_b_normalizes_hardcover():
schema = load_schema('hep')
subschema = schema['properties']['isbns']
snippet = (
'<datafield tag="020" ind1=" " ind2=" ">'
' <subfield code="a">978-981-4571-66-1</subfield>'
' <subfield code="b">hardcover</subfield>'
'</datafield>'
) # record/1351311
expected = [
{
'value': '9789814571661',
'medium': 'hardcover',
},
]
result = hep.do(create_record(snippet))
assert validate(result['isbns'], subschema) is None
assert expected == result['isbns']
expected = [
{
'a': '9789814571661',
'b': 'hardcover',
},
]
result = hep2marc.do(result)
assert expected == result['020']
def test_dois_from_0247_a_2_double_9_ignores_curator_source():
schema = load_schema('hep')
subschema = schema['properties']['dois']
snippet = (
'<datafield tag="024" ind1="7" ind2=" ">'
' <subfield code="2">DOI</subfield>'
' <subfield code="9">bibcheck</subfield>'
' <subfield code="9">CURATOR</subfield>'
' <subfield code="a">10.1590/S1806-11172008005000006</subfield>'
'</datafield>'
) # record/1117362
expected = [
{
'source': 'bibcheck',
'value': '10.1590/S1806-11172008005000006',
},
]
result = hep.do(create_record(snippet)) # no roundtrip
assert validate(result['dois'], subschema) is None
assert expected == result['dois']
expected = [
{
'a': '10.1590/S1806-11172008005000006',
'9': 'bibcheck',
'2': 'DOI',
},
]
result = hep2marc.do(result)
assert expected == result['0247']
def test_isbns_from_020__a_b_normalizes_electronic():
schema = load_schema('hep')
subschema = schema['properties']['isbns']
snippet = (
'<datafield tag="020" ind1=" " ind2=" ">'
' <subfield code="a">9783319006260</subfield>'
' <subfield code="b">electronic version</subfield>'
'</datafield>'
) # record/1292006
expected = [
{
'value': '9783319006260',
},
]
result = hep.do(create_record(snippet))
assert validate(result['isbns'], subschema) is None
assert expected == result['isbns']
expected = [
{
'a': '9783319006260',
},
]
result = hep2marc.do(result)
assert expected == result['020']
def test_isbns_from_020__a_b_normalizes_ebook():
schema = load_schema('hep')
subschema = schema['properties']['isbns']
snippet = (
'<datafield tag="020" ind1=" " ind2=" ">'
' <subfield code="a">9783319259017</subfield>'
' <subfield code="b">eBook</subfield>'
'</datafield>'
) # record/1430829
expected = [
{
'value': '9783319259017',
'medium': 'online',
},
]
result = hep.do(create_record(snippet))
assert validate(result['isbns'], subschema) is None
assert expected == result['isbns']
expected = [
{
'a': '9783319259017',
'b': 'online',
},
]
result = hep2marc.do(result)
assert expected == result['020']
def test_report_numbers_hidden_from_037__z():
schema = load_schema('hep')
subschema = schema['properties']['report_numbers']
snippet = (
'<datafield tag="037" ind1=" " ind2=" ">'
' <subfield code="z">FERMILAB-PUB-17-011-CMS</subfield>'
'</datafield>'
) # record/1508174
expected = [
{
'hidden': True,
'value': 'FERMILAB-PUB-17-011-CMS',
},
]
result = hep.do(create_record(snippet))
assert validate(result['report_numbers'], subschema) is None
assert expected == result['report_numbers']
expected = [
{'z': 'FERMILAB-PUB-17-011-CMS'}
]
result = hep2marc.do(result)
assert expected == result['037']
def test_isbns_from_020__a_b_normalizes_print():
schema = load_schema('hep')
subschema = schema['properties']['isbns']
snippet = (
'<datafield tag="020" ind1=" " ind2=" ">'
' <subfield code="a">9781786341105</subfield>'
' <subfield code="b">Print</subfield>'
'</datafield>'
) # record/1509456
expected = [
{
'value': '9781786341105',
'medium': 'print',
},
]
result = hep.do(create_record(snippet))
assert validate(result['isbns'], subschema) is None
assert expected == result['isbns']
expected = [
{
'a': '9781786341105',
'b': 'print',
},
]
result = hep2marc.do(result)
assert expected == result['020']
def test_positions_from_371__a():
schema = load_schema('authors')
subschema = schema['properties']['positions']
snippet = (
'<datafield tag="371" ind1=" " ind2=" ">'
' <subfield code="a">Aachen, Tech. Hochsch.</subfield>'
'</datafield>'
) # record/997958
expected = [
{
'current': False,
'institution': {
'curated_relation': False,
'name': 'Aachen, Tech. Hochsch.',
},
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['positions'], subschema) is None
assert expected == result['positions']
expected = [
{'a': 'Aachen, Tech. Hochsch.'}
]
result = hepnames2marc.do(result)
assert expected == result['371']
def test_report_numbers_from_037__z_9():
schema = load_schema('hep')
subschema = schema['properties']['report_numbers']
snippet = (
'<datafield tag="037" ind1=" " ind2=" ">'
' <subfield code="9">SLAC</subfield>'
' <subfield code="a">SLAC-PUB-16140</subfield>'
'</datafield>'
) # record/1326454
expected = [
{
'source': 'SLAC',
'value': 'SLAC-PUB-16140',
},
]
result = hep.do(create_record(snippet))
assert validate(result['report_numbers'], subschema) is None
assert expected == result['report_numbers']
expected = [
{
'9': 'SLAC',
'a': 'SLAC-PUB-16140',
},
]
result = hep2marc.do(result)
assert expected == result['037']
def test_status_from_100__a_g_q():
schema = load_schema('authors')
subschema = schema['properties']['status']
snippet = (
'<datafield tag="100" ind1=" " ind2=" ">'
' <subfield code="a">Abarbanel, Henry D.I.</subfield>'
' <subfield code="q">Henry D.I. Abarbanel</subfield>'
' <subfield code="g">ACTIVE</subfield>'
'</datafield>'
) # record/1019100
expected = 'active'
result = hepnames.do(create_record(snippet))
assert validate(result['status'], subschema) is None
assert expected == result['status']
expected = {
'a': 'Abarbanel, Henry D.I.',
'q': 'Henry D.I. Abarbanel',
'g': 'active',
}
result = hepnames2marc.do(result)
assert expected == result['100']
def test_ids_from_035__a_9_with_scopus():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">SCOPUS</subfield>'
' <subfield code="a">7103280792</subfield>'
'</datafield>'
) # record/1017182/export/xme
expected = [
{
'schema': 'SCOPUS',
'value': '7103280792',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'SCOPUS',
'a': '7103280792',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_9_with_viaf():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">VIAF</subfield>'
' <subfield code="a">34517183</subfield>'
'</datafield>'
) # record/1008109/export/xme
expected = [
{
'schema': 'VIAF',
'value': '34517183',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'VIAF',
'a': '34517183',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_9_with_researcherid():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">RESEARCHERID</subfield>'
' <subfield code="a">B-4717-2008</subfield>'
'</datafield>'
) # record/1051026/export/xme
expected = [
{
'schema': 'RESEARCHERID',
'value': 'B-4717-2008',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'RESEARCHERID',
'a': 'B-4717-2008',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_with_bai():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="a">Jian.Long.Han.1</subfield>'
'</datafield>'
) # record/1464894/export/xme
expected = [
{
'schema': 'INSPIRE BAI',
'value': 'Jian.Long.Han.1',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'BAI',
'a': 'Jian.Long.Han.1',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_9_with_googlescholar():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">GoogleScholar</subfield>'
' <subfield code="a">Tnl-9KoAAAAJ</subfield>'
'</datafield>'
) # record/1467553/export/xme
expected = [
{
'schema': 'GOOGLESCHOLAR',
'value': 'Tnl-9KoAAAAJ',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'GOOGLESCHOLAR',
'a': 'Tnl-9KoAAAAJ',
},
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_ids_from_035__a_9_with_orcid():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = (
'<datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="9">ORCID</subfield>'
' <subfield code="a">0000-0001-6771-2174</subfield>'
'</datafield>'
)
expected = [
{
'schema': 'ORCID',
'value': '0000-0001-6771-2174',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [
{
'9': 'ORCID',
'a': '0000-0001-6771-2174',
}
]
result = hepnames2marc.do(result)
assert expected == result['035']
def test_other_names_from_400__triple_a():
schema = load_schema('authors')
subschema = schema['properties']['other_names']
snippet = (
'<datafield tag="400" ind1=" " ind2=" ">'
' <subfield code="a">Yosef Cohen, Hadar</subfield>'
' <subfield code="a">Josef Cohen, Hadar</subfield>'
' <subfield code="a">Cohen, Hadar Josef</subfield>'
'</datafield>'
) # record/1292399/export/xme
expected = [
'Yosef Cohen, Hadar',
'Josef Cohen, Hadar',
'Cohen, Hadar Josef',
]
result = hepnames.do(create_record(snippet))
assert validate(result['other_names'], subschema) is None
assert expected == result['other_names']
expected = [
{'a': 'Yosef Cohen, Hadar'},
{'a': 'Josef Cohen, Hadar'},
{'a': 'Cohen, Hadar Josef'},
]
result = hepnames2marc.do(result)
assert expected == result['400']
def test_report_numbers_from_two_037__a():
schema = load_schema('hep')
subschema = schema['properties']['report_numbers']
snippet = (
'<record>'
' <datafield tag="037" ind1=" " ind2=" ">'
' <subfield code="a">UTPT-89-27</subfield>'
' </datafield>'
' <datafield tag="037" ind1=" " ind2=" ">'
' <subfield code="a">CALT-68-1585</subfield>'
' </datafield>'
'</record>'
) # record/26564
expected = [
{
'value': 'UTPT-89-27',
},
{
'value': 'CALT-68-1585',
},
]
result = hep.do(create_record(snippet))
assert validate(result['report_numbers'], subschema) is None
assert expected == result['report_numbers']
expected = [
{'a': 'UTPT-89-27'},
{'a': 'CALT-68-1585'},
]
result = hep2marc.do(result)
assert expected == result['037']
def test_add_uid_handles_dois():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_uid('http://dx.doi.org/10.3972/water973.0145.db')
expected = [
{
'reference': {
'dois': [
'10.3972/water973.0145.db',
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_issn_from_022__a_b():
schema = load_schema('journals')
subschema = schema['properties']['issn']
snippet = (
'<datafield tag="022" ind1=" " ind2=" ">'
' <subfield code="a">1812-9471</subfield>'
' <subfield code="b">Print</subfield>'
'</datafield>'
) # record/1513418
expected = [
{
'medium': 'print',
'value': '1812-9471',
},
]
result = journals.do(create_record(snippet))
assert validate(result['issn'], subschema) is None
assert expected == result['issn']
def test_add_uid_rejects_invalid_isbns():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_uid('123456789')
expected = [
{
'reference': {
'misc': [
'123456789',
]
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_url_uses_fix_url():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_url('www.muonsinc.com')
expected = [
{
'reference': {
'urls': [
{'value': 'http://www.muonsinc.com'},
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_url_adds_uid():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_url('10.1109/NSSMIC.2005.1596597')
expected = [
{
'reference': {
'dois': [
'10.1109/NSSMIC.2005.1596597'
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_set_journal_title():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.set_journal_title('Phys. Rev. D')
expected = [
{
'reference': {
'publication_info': {
'journal_title': 'Phys. Rev. D'
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_collaboration():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_collaboration('ALICE')
expected = [
{
'reference': {
'collaborations': [
'ALICE',
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_set_imprint_date():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.set_imprint_date('23/12/2015')
expected = [
{
'reference': {
'imprint': {
'date': '2015-12-23',
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_uid_handles_cnums():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_uid('C87-11-11')
expected = [
{
'reference': {
'publication_info': {
'cnum': 'C87-11-11',
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_set_year():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.set_year(2017)
expected = [
{
'reference': {
'publication_info': {
'year': 2017,
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_set_imprint_place():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.set_imprint_place('New York')
expected = [
{
'reference': {
'imprint': {
'place': 'New York',
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_parent_title():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_parent_title('Geom. Funct. Anal., GAFA 2000')
expected = [
{
'reference': {
'publication_info': {
'parent_title': 'Geom. Funct. Anal., GAFA 2000',
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_set_publisher():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.set_publisher('Elsevier')
expected = [
{
'reference': {
'imprint': {
'publisher': 'Elsevier',
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_url_rejects_empty_ads_id():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_url('http://adsabs.harvard.edu/abs/')
expected = [
{
'reference': {
'urls': [{
'value': 'http://adsabs.harvard.edu/abs/'
}],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_misc():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_misc('[Erratum:')
expected = [
{
'reference': {
'misc': [
'[Erratum:',
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_set_page_artid_none():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.set_page_artid(None, None, '014568')
expected = [
{
'reference': {
'publication_info': {
'artid': '014568',
},
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_title():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_title('The CMS experiment at the CERN LHC')
expected = [
{
'reference': {
'title': {
'title': 'The CMS experiment at the CERN LHC',
}
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_author():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_author('Cox, Brian')
expected = [
{
'reference': {
'authors': [
{'full_name': 'Cox, Brian'},
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_url_rejects_empty_cds_id():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_url('https://cds.cern.ch/record/')
expected = [
{
'reference': {
'urls': [{
'value': 'https://cds.cern.ch/record/'
}],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_refextract_authors_str_unicode():
schema = load_schema('hep')
subschema = schema['properties']['references']
builder = ReferenceBuilder()
builder.add_refextract_authors_str(u'Kätlne, J.')
expected = [
{
'reference': {
'authors': [
{'full_name': u'Kätlne, J.'},
],
},
},
]
result = [builder.obj]
assert validate(result, subschema) is None
assert expected == result
def test_add_many_external_system_identifier():
schema = load_schema('hep')
subschema = schema['properties']['external_system_identifiers']
builder = LiteratureBuilder()
builder.add_external_system_identifier('5758037', 'osti')
builder.add_external_system_identifier('1992PhRvD..45..124K', 'ADS')
result = builder.record['external_system_identifiers']
expected = [
{
'value': '5758037',
'schema': 'osti',
},
{
'value': '1992PhRvD..45..124K',
'schema': 'ADS',
},
]
assert validate(result, subschema) is None
assert expected == result
def test_journal_titles_from_130__a_b():
schema = load_schema('journals')
subschema = schema['properties']['journal_titles']
snippet = (
'<datafield tag="130" ind1=" " ind2=" ">'
' <subfield code="a">Humana Mente</subfield>'
' <subfield code="b">Journal of Philosophical Studies</subfield>'
'</datafield>'
)
expected = [
{
'title': 'Humana Mente',
'subtitle': 'Journal of Philosophical Studies',
},
]
result = journals.do(create_record(snippet))
assert validate(result['journal_titles'], subschema) is None
assert expected == result['journal_titles']
def test_hidden_notes_from_595__double_a_9():
schema = load_schema('hep')
subschema = schema['properties']['hidden_notes']
snippet = (
'<datafield tag="595" ind1=" " ind2=" ">'
' <subfield code="9">SPIRES-HIDDEN</subfield>'
' <subfield code="a">TeXtitle from script</subfield>'
' <subfield code="a">no affiliation (not clear pn the fulltext)</subfield>'
'</datafield>'
) # record/109310
expected = [
{
'source': 'SPIRES-HIDDEN',
'value': 'TeXtitle from script',
},
{
'source': 'SPIRES-HIDDEN',
'value': 'no affiliation (not clear pn the fulltext)',
},
]
result = hep.do(create_record(snippet))
assert validate(result['hidden_notes'], subschema) is None
assert expected == result['hidden_notes']
expected = [
{
'9': 'SPIRES-HIDDEN',
'a': 'TeXtitle from script',
},
{
'9': 'SPIRES-HIDDEN',
'a': 'no affiliation (not clear pn the fulltext)',
},
]
result = hep2marc.do(result)
assert expected == result['595']
def test_public_notes_from_500__a_and_500__a_9():
schema = load_schema('hep')
subschema = schema['properties']['public_notes']
snippet = ('<record>'
' <datafield tag="500" ind1=" " ind2=" ">'
' <subfield code="a">*Brief entry*</subfield>'
' </datafield>'
' <datafield tag="500" ind1=" " ind2=" ">'
' <subfield code="a">11 pages, 5 figures</subfield>'
' <subfield code="9">arXiv</subfield>'
' </datafield>'
'</record>') # record/1450045
expected = [
{
'value': '*Brief entry*',
},
{
'source': 'arXiv',
'value': '11 pages, 5 figures',
},
]
result = hep.do(create_record(snippet))
assert validate(result['public_notes'], subschema) is None
assert expected == result['public_notes']
expected = [
{
'a': '*Brief entry*',
},
{
'9': 'arXiv',
'a': '11 pages, 5 figures',
},
]
result = hep2marc.do(result)
assert expected == result['500']
def test_ids_from_double_035__a_9():
schema = load_schema('authors')
subschema = schema['properties']['ids']
snippet = ('<record>'
' <datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="a">INSPIRE-00134135</subfield>'
' <subfield code="9">INSPIRE</subfield>'
' </datafield>'
' <datafield tag="035" ind1=" " ind2=" ">'
' <subfield code="a">H.Vogel.1</subfield>'
' <subfield code="9">BAI</subfield>'
' </datafield>'
'</record>') # record/984519
expected = [
{
'schema': 'INSPIRE ID',
'value': 'INSPIRE-00134135',
},
{
'schema': 'INSPIRE BAI',
'value': 'H.Vogel.1',
},
]
result = hepnames.do(create_record(snippet))
assert validate(result['ids'], subschema) is None
assert expected == result['ids']
expected = [{
'a': 'INSPIRE-00134135',
'9': 'INSPIRE'
}, {
'a': 'H.Vogel.1',
'9': 'BAI'
}]
result = hepnames2marc.do(result)
assert sorted(expected) == sorted(result['035'])
def test_convert_old_publication_info_to_new_handles_hidden_without_volume_variations(
):
schema = utils.load_schema('hep')
subschema = schema['properties']['publication_info']
publication_info = [
{
'artid': 'R10587',
'journal_record': {
'$ref': 'http://localhost:5000/api/journals/1214516',
},
'journal_title': 'Phys.Rev.',
'journal_volume': 'B61',
},
{
'artid': '10587',
'hidden': True,
'journal_title': 'Phys.Rev.',
'journal_volume': 'B61',
},
]
assert utils.validate(publication_info, subschema) is None
expected = [
{
'artid': 'R10587',
'journal_title': 'Phys.Rev.B',
'journal_volume': '61',
},
{
'artid': '10587',
'hidden': True,
'journal_title': 'Phys.Rev.B',
'journal_volume': '61',
},
]
result = utils.convert_old_publication_info_to_new(publication_info)
assert utils.validate(result, subschema) is None
assert expected == result
def test_project_type_from_double_980__a_recognizes_accelerators():
schema = load_schema('experiments')
subschema = schema['properties']['project_type']
snippet = (
'<record>'
' <datafield tag="980" ind1=" " ind2=" ">'
' <subfield code="a">ACCELERATOR</subfield>'
' </datafield>'
' <datafield tag="980" ind1=" " ind2=" ">'
' <subfield code="a">EXPERIMENT</subfield>'
' </datafield>'
'</record>'
) # record/1607855
expected = [
'accelerator',
]
result = experiments.do(create_record(snippet))
assert validate(result['project_type'], subschema) is None
assert expected == result['project_type']
def test_collaboration_from_710__g_0():
schema = load_schema('experiments')
subschema = schema['properties']['collaboration']
snippet = (
'<datafield tag="710" ind1=" " ind2=" ">'
' <subfield code="g">DarkSide</subfield>'
' <subfield code="0">1108199</subfield>'
'</datafield>'
) # record/1108199
expected = {
'curated_relation': True,
'record': {
'$ref': 'http://localhost:5000/api/experiments/1108199',
},
'value': 'DarkSide',
}
result = experiments.do(create_record(snippet))
assert validate(result['collaboration'], subschema) is None
assert expected == result['collaboration']
def test_related_records_from_double_510__a_w_0_accepts_predecessors():
schema = load_schema('experiments')
subschema = schema['properties']['related_records']
snippet = (
'<record>'
' <datafield tag="510" ind1=" " ind2=" ">'
' <subfield code="0">1108293</subfield>'
' <subfield code="a">XENON</subfield>'
' <subfield code="w">a</subfield>'
' </datafield>'
' <datafield tag="510" ind1=" " ind2=" ">'
' <subfield code="0">1386527</subfield>'
' <subfield code="a">XENON100</subfield>'
' <subfield code="w">a</subfield>'
' </datafield>'
'</record>'
) # record/1386519
expected = [
{
'curated_relation': True,
'record': {
'$ref': 'http://localhost:5000/api/experiments/1108293',
},
'relation': 'predecessor',
},
{
'curated_relation': True,
'record': {
'$ref': 'http://localhost:5000/api/experiments/1386527',
},
'relation': 'predecessor',
},
]
result = experiments.do(create_record(snippet))
assert validate(result['related_records'], subschema) is None
assert expected == result['related_records']
def test_draft_validate():
schema = utils.load_schema('hep')
record = {
'_collections': [
'Literature',
],
'document_type': [
'article',
],
'titles': [
{'title': 'A title'},
],
'preprint_date': 'Jessica Jones'
}
expected = 'Jessica Jones'
result = utils.get_validation_errors(record, schema)
error = next(result)
assert expected in error.message
with pytest.raises(StopIteration):
error = next(result)
