Page MenuHomec4science
Files F60134928

bibrecord_tests.py
No OneTemporary
Actions

File Metadata

Created
Sat, Apr 27, 18:48

bibrecord_tests.py
View Options

# -*- coding: utf-8 -*-
##
## This file is part of Invenio.
## Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 CERN.
##
## Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or (at your option) any later version.
##
## Invenio is distributed in the hope that it will be useful, but
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
## General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""
The BibRecord test suite.
"""
import unittest
from invenio.config import CFG_TMPDIR
from invenio import bibrecord, bibrecord_config
from invenio.testutils import make_test_suite, run_test_suite
try:
import pyRXP
parser_pyrxp_available = True
except ImportError:
parser_pyrxp_available = False
try:
import Ft.Xml.Domlette
parser_4suite_available = True
except ImportError:
parser_4suite_available = False
try:
import xml.dom.minidom
import xml.parsers.expat
parser_minidom_available = True
except ImportError:
parser_minidom_available = False
class BibRecordSuccessTest(unittest.TestCase):
""" bibrecord - demo file parsing test """
def setUp(self):
"""Initialize stuff"""
f = open(CFG_TMPDIR + '/demobibdata.xml', 'r')
xmltext = f.read()
f.close()
self.recs = [rec[0] for rec in bibrecord.create_records(xmltext)]
def test_records_created(self):
""" bibrecord - demo file how many records are created """
self.assertEqual(104, len(self.recs))
def test_tags_created(self):
""" bibrecord - demo file which tags are created """
## check if the tags are correct
tags = ['003', '005', '020', '024', '035', '037', '041', '080', '088',
'100', '242', '245', '246', '250', '260', '269', '270', '300',
'340', '490', '500', '502', '506', '520', '590', '595', '650',
'653', '690', '694', '695', '700', '710', '720', '773', '856',
'859', '901', '909', '916', '960', '961', '962', '963', '964',
'970', '980', '999', 'FFT']
t = []
for rec in self.recs:
t.extend(rec.keys())
t.sort()
#eliminate the elements repeated
tt = []
for x in t:
if not x in tt:
tt.append(x)
self.assertEqual(tags, tt)
def test_fields_created(self):
"""bibrecord - demo file how many fields are created"""
## check if the number of fields for each record is correct
fields = [14, 14, 8, 11, 11, 13, 11, 15, 10, 18, 14, 16, 10, 9, 15, 10,
11, 11, 11, 9, 11, 11, 10, 9, 9, 9, 10, 9, 10, 10, 8, 9, 8,
9, 14, 13, 14, 14, 15, 12, 13, 12, 15, 14, 12, 16, 16, 15,
15, 14, 16, 15, 15, 15, 16, 15, 16, 15, 15, 16, 15, 14, 14,
15, 12, 13, 11, 15, 8, 11, 14, 13, 12, 13, 6, 6, 25, 24, 27,
26, 26, 24, 26, 27, 25, 28, 24, 23, 27, 25, 25, 26, 26, 24,
19, 26, 25, 22, 9, 8, 9, 9, 8, 7]
cr = []
ret = []
for rec in self.recs:
cr.append(len(rec.values()))
ret.append(rec)
self.assertEqual(fields, cr)
def test_create_record_with_collection_tag(self):
""" bibrecord - create_record() for single record in collection"""
xmltext = """
<collection>
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
</record>
</collection>
"""
record = bibrecord.create_record(xmltext)
record1 = bibrecord.create_records(xmltext)[0]
self.assertEqual(record1, record)
class BibRecordParsersTest(unittest.TestCase):
""" bibrecord - testing the creation of records with different parsers"""
def setUp(self):
"""Initialize stuff"""
self.xmltext = """
<!-- A first comment -->
<collection>
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<!-- A second comment -->
<subfield code="a">eng</subfield>
</datafield>
</record>
</collection>
"""
self.expected_record = {
'001': [([], ' ', ' ', '33', 1)],
'041': [([('a', 'eng')], ' ', ' ', '', 2)]
}
if parser_pyrxp_available:
def test_pyRXP(self):
""" bibrecord - create_record() with pyRXP """
record = bibrecord._create_record_rxp(self.xmltext)
self.assertEqual(record, self.expected_record)
if parser_4suite_available:
def test_4suite(self):
""" bibrecord - create_record() with 4suite """
record = bibrecord._create_record_4suite(self.xmltext)
self.assertEqual(record, self.expected_record)
if parser_minidom_available:
def test_minidom(self):
""" bibrecord - create_record() with minidom """
record = bibrecord._create_record_minidom(self.xmltext)
self.assertEqual(record, self.expected_record)
class BibRecordBadInputTreatmentTest(unittest.TestCase):
""" bibrecord - testing for bad input treatment """
def test_empty_collection(self):
"""bibrecord - empty collection"""
xml_error0 = """<collection></collection>"""
rec = bibrecord.create_record(xml_error0)[0]
self.assertEqual(rec, {})
records = bibrecord.create_records(xml_error0)
self.assertEqual(len(records), 0)
def test_wrong_attribute(self):
"""bibrecord - bad input subfield \'cde\' instead of \'code\'"""
ws = bibrecord.CFG_BIBRECORD_WARNING_MSGS
xml_error1 = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe, John</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield cde="a">On the foo and bar</subfield>
</datafield>
</record>
"""
e = bibrecord.create_record(xml_error1, 1, 1)[2]
ee =''
for i in e:
if type(i).__name__ == 'str':
if i.count(ws[3])>0:
ee = i
self.assertEqual(bibrecord._warning((3, '(field number: 4)')), ee)
def test_missing_attribute(self):
""" bibrecord - bad input missing \"tag\" """
ws = bibrecord.CFG_BIBRECORD_WARNING_MSGS
xml_error2 = """
<record>
<controlfield tag="001">33</controlfield>
<datafield ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe, John</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">On the foo and bar</subfield>
</datafield>
</record>
"""
e = bibrecord.create_record(xml_error2, 1, 1)[2]
ee = ''
for i in e:
if type(i).__name__ == 'str':
if i.count(ws[1])>0:
ee = i
self.assertEqual(bibrecord._warning((1, '(field number(s): [2])')), ee)
def test_empty_datafield(self):
""" bibrecord - bad input no subfield """
ws = bibrecord.CFG_BIBRECORD_WARNING_MSGS
xml_error3 = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe, John</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">On the foo and bar</subfield>
</datafield>
</record>
"""
e = bibrecord.create_record(xml_error3, 1, 1)[2]
ee = ''
for i in e:
if type(i).__name__ == 'str':
if i.count(ws[8])>0:
ee = i
self.assertEqual(bibrecord._warning((8, '(field number: 2)')), ee)
def test_missing_tag(self):
"""bibrecord - bad input missing end \"tag\" """
ws = bibrecord.CFG_BIBRECORD_WARNING_MSGS
xml_error4 = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe, John</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">On the foo and bar</subfield>
</record>
"""
e = bibrecord.create_record(xml_error4, 1, 1)[2]
ee = ''
for i in e:
if type(i).__name__ == 'str':
if i.count(ws[99])>0:
ee = i
self.assertEqual(bibrecord._warning((99, '(Tagname : datafield)')), ee)
class BibRecordAccentedUnicodeLettersTest(unittest.TestCase):
""" bibrecord - testing accented UTF-8 letters """
def setUp(self):
"""Initialize stuff"""
self.xml_example_record = """<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Döè1, John</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, J>ohn</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">Пушкин</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>"""
self.rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
def test_accented_unicode_characters(self):
"""bibrecord - accented Unicode letters"""
self.assertEqual(self.xml_example_record,
bibrecord.record_xml_output(self.rec))
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "100", " ", " "),
[([('a', 'Döè1, John')], " ", " ", "", 3), ([('a', 'Doe2, J>ohn'), ('b', 'editor')], " ", " ", "", 4)])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "245", " ", "1"),
[([('a', 'Пушкин')], " ", '1', "", 5)])
class BibRecordGettingFieldValuesTest(unittest.TestCase):
""" bibrecord - testing for getting field/subfield values """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe1, John</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_get_field_instances(self):
"""bibrecord - getting field instances"""
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "100", " ", " "),
[([('a', 'Doe1, John')], " ", " ", "", 3), ([('a', 'Doe2, John'), ('b', 'editor')], " ", " ", "", 4)])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "", " ", " "),
[('245', [([('a', 'On the foo and bar1')], " ", '1', "", 5), ([('a', 'On the foo and bar2')], " ", '2', "", 6)]), ('001', [([], " ", " ", '33', 1)]), ('100', [([('a', 'Doe1, John')], " ", " ", "", 3), ([('a', 'Doe2, John'), ('b', 'editor')], " ", " ", "", 4)]), ('041', [([('a', 'eng')], " ", " ", "", 2)])])
def test_get_field_values(self):
"""bibrecord - getting field values"""
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "a"),
['Doe1, John', 'Doe2, John'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "b"),
['editor'])
def test_get_field_value(self):
"""bibrecord - getting first field value"""
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", " ", " ", "a"),
'Doe1, John')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", " ", " ", "b"),
'editor')
def test_get_subfield_values(self):
"""bibrecord - getting subfield values"""
fi1, fi2 = bibrecord.record_get_field_instances(self.rec, "100", " ", " ")
self.assertEqual(bibrecord.field_get_subfield_values(fi1, "b"), [])
self.assertEqual(bibrecord.field_get_subfield_values(fi2, "b"), ["editor"])
class BibRecordGettingFieldValuesViaWildcardsTest(unittest.TestCase):
""" bibrecord - testing for getting field/subfield values via wildcards """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">1</controlfield>
<datafield tag="100" ind1="C" ind2="5">
<subfield code="a">val1</subfield>
</datafield>
<datafield tag="555" ind1="A" ind2="B">
<subfield code="a">val2</subfield>
</datafield>
<datafield tag="555" ind1="A" ind2=" ">
<subfield code="a">val3</subfield>
</datafield>
<datafield tag="555" ind1=" " ind2=" ">
<subfield code="a">val4a</subfield>
<subfield code="b">val4b</subfield>
</datafield>
<datafield tag="555" ind1=" " ind2="B">
<subfield code="a">val5</subfield>
</datafield>
<datafield tag="556" ind1="A" ind2="C">
<subfield code="a">val6</subfield>
</datafield>
<datafield tag="556" ind1="A" ind2=" ">
<subfield code="a">val7a</subfield>
<subfield code="b">val7b</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_get_field_instances_via_wildcard(self):
"""bibrecord - getting field instances via wildcards"""
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "100", " ", " "),
[])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "100", "%", " "),
[])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "100", "%", "%"),
[([('a', 'val1')], 'C', '5', "", 2)])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "55%", "A", "%"),
[([('a', 'val2')], 'A', 'B', "", 3),
([('a', 'val3')], 'A', " ", "", 4),
([('a', 'val6')], 'A', 'C', "", 7),
([('a', 'val7a'), ('b', 'val7b')], 'A', " ", "", 8)])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "55%", "A", " "),
[([('a', 'val3')], 'A', " ", "", 4),
([('a', 'val7a'), ('b', 'val7b')], 'A', " ", "", 8)])
self.assertEqual(bibrecord.record_get_field_instances(self.rec, "556", "A", " "),
[([('a', 'val7a'), ('b', 'val7b')], 'A', " ", "", 8)])
def test_get_field_values_via_wildcard(self):
"""bibrecord - getting field values via wildcards"""
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", " "),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", "%", " ", " "),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", "%", " "),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", "%", "%", " "),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", "%", "%", "z"),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "%"),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "a"),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", "%", " ", "a"),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", "%", "%", "a"),
['val1'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", "%", "%", "%"),
['val1'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "A", "%", "a"),
['val2', 'val3', 'val6', 'val7a'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "A", " ", "a"),
['val3', 'val7a'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "556", "A", " ", "a"),
['val7a'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "555", " ", " ", " "),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "555", " ", " ", "z"),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "555", " ", " ", "%"),
['val4a', 'val4b'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", " ", " ", "b"),
['val4b'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "%", "%", "b"),
['val4b', 'val7b'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "A", " ", "b"),
['val7b'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "A", "%", "b"),
['val7b'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "A", " ", "a"),
['val3', 'val7a'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "A", "%", "a"),
['val2', 'val3', 'val6', 'val7a'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", "%", "%", "a"),
['val2', 'val3', 'val4a', 'val5', 'val6', 'val7a'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "55%", " ", " ", "a"),
['val4a'])
def test_get_field_value_via_wildcard(self):
"""bibrecord - getting first field value via wildcards"""
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", " ", " ", " "),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", "%", " ", " "),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", " ", "%", " "),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", "%", "%", " "),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", " ", " ", "%"),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", " ", " ", "a"),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", "%", " ", "a"),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", "%", "%", "a"),
'val1')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "100", "%", "%", "%"),
'val1')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "A", "%", "a"),
'val2')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "A", " ", "a"),
'val3')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "556", "A", " ", "a"),
'val7a')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "555", " ", " ", " "),
'')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "555", " ", " ", "%"),
'val4a')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", " ", " ", "b"),
'val4b')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "%", "%", "b"),
'val4b')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "A", " ", "b"),
'val7b')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "A", "%", "b"),
'val7b')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "A", " ", "a"),
'val3')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "A", "%", "a"),
'val2')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", "%", "%", "a"),
'val2')
self.assertEqual(bibrecord.record_get_field_value(self.rec, "55%", " ", " ", "a"),
'val4a')
class BibRecordAddFieldTest(unittest.TestCase):
""" bibrecord - testing adding field """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe1, John</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_add_controlfield(self):
"""bibrecord - adding controlfield"""
field_position_global_1 = bibrecord.record_add_field(self.rec, "003",
controlfield_value="SzGeCERN")
field_position_global_2 = bibrecord.record_add_field(self.rec, "004",
controlfield_value="Test")
self.assertEqual(field_position_global_1, 2)
self.assertEqual(field_position_global_2, 3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "003", " ", " ", ""),
['SzGeCERN'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "004", " ", " ", ""),
['Test'])
def test_add_datafield(self):
"""bibrecord - adding datafield"""
field_position_global_1 = bibrecord.record_add_field(self.rec, "100",
subfields=[('a', 'Doe3, John')])
field_position_global_2 = bibrecord.record_add_field(self.rec, "100",
subfields= [('a', 'Doe4, John'), ('b', 'editor')])
self.assertEqual(field_position_global_1, 5)
self.assertEqual(field_position_global_2, 6)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "a"),
['Doe1, John', 'Doe2, John', 'Doe3, John', 'Doe4, John'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "b"),
['editor', 'editor'])
def test_add_controlfield_on_desired_position(self):
"""bibrecord - adding controlfield on desired position"""
field_position_global_1 = bibrecord.record_add_field(self.rec, "005",
controlfield_value="Foo",
field_position_global=0)
field_position_global_2 = bibrecord.record_add_field(self.rec, "006",
controlfield_value="Bar",
field_position_global=0)
self.assertEqual(field_position_global_1, 7)
self.assertEqual(field_position_global_2, 8)
def test_add_datafield_on_desired_position_field_position_global(self):
"""bibrecord - adding datafield on desired global field position"""
field_position_global_1 = bibrecord.record_add_field(self.rec, "100",
subfields=[('a', 'Doe3, John')], field_position_global=0)
field_position_global_2 = bibrecord.record_add_field(self.rec, "100",
subfields=[('a', 'Doe4, John'), ('b', 'editor')], field_position_global=0)
self.assertEqual(field_position_global_1, 3)
self.assertEqual(field_position_global_2, 3)
def test_add_datafield_on_desired_position_field_position_local(self):
"""bibrecord - adding datafield on desired local field position"""
field_position_global_1 = bibrecord.record_add_field(self.rec, "100",
subfields=[('a', 'Doe3, John')], field_position_local=0)
field_position_global_2 = bibrecord.record_add_field(self.rec, "100",
subfields=[('a', 'Doe4, John'), ('b', 'editor')],
field_position_local=2)
self.assertEqual(field_position_global_1, 3)
self.assertEqual(field_position_global_2, 5)
class BibRecordManageMultipleFieldsTest(unittest.TestCase):
""" bibrecord - testing the management of multiple fields """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">subfield1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">subfield2</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">subfield3</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">subfield4</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_delete_multiple_datafields(self):
"""bibrecord - deleting multiple datafields"""
self.fields = bibrecord.record_delete_fields(self.rec, '245', [1, 2])
self.assertEqual(self.fields[0],
([('a', 'subfield2')], ' ', ' ', '', 3))
self.assertEqual(self.fields[1],
([('a', 'subfield3')], ' ', ' ', '', 4))
def test_add_multiple_datafields_default_index(self):
"""bibrecord - adding multiple fields with the default index"""
fields = [([('a', 'subfield5')], ' ', ' ', '', 4),
([('a', 'subfield6')], ' ', ' ', '', 19)]
index = bibrecord.record_add_fields(self.rec, '245', fields)
self.assertEqual(index, None)
self.assertEqual(self.rec['245'][-2],
([('a', 'subfield5')], ' ', ' ', '', 6))
self.assertEqual(self.rec['245'][-1],
([('a', 'subfield6')], ' ', ' ', '', 7))
def test_add_multiple_datafields_with_index(self):
"""bibrecord - adding multiple fields with an index"""
fields = [([('a', 'subfield5')], ' ', ' ', '', 4),
([('a', 'subfield6')], ' ', ' ', '', 19)]
index = bibrecord.record_add_fields(self.rec, '245', fields,
field_position_local=0)
self.assertEqual(index, 0)
self.assertEqual(self.rec['245'][0],
([('a', 'subfield5')], ' ', ' ', '', 2))
self.assertEqual(self.rec['245'][1],
([('a', 'subfield6')], ' ', ' ', '', 3))
self.assertEqual(self.rec['245'][2],
([('a', 'subfield1')], ' ', ' ', '', 4))
def test_move_multiple_fields(self):
"""bibrecord - move multiple fields"""
bibrecord.record_move_fields(self.rec, '245', [1, 3])
self.assertEqual(self.rec['245'][0],
([('a', 'subfield1')], ' ', ' ', '', 2))
self.assertEqual(self.rec['245'][1],
([('a', 'subfield3')], ' ', ' ', '', 4))
self.assertEqual(self.rec['245'][2],
([('a', 'subfield2')], ' ', ' ', '', 5))
self.assertEqual(self.rec['245'][3],
([('a', 'subfield4')], ' ', ' ', '', 6))
class BibRecordDeleteFieldTest(unittest.TestCase):
""" bibrecord - testing field deletion """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe1, John</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
xml_example_record_empty = """
<record>
</record>
"""
self.rec_empty = bibrecord.create_record(xml_example_record_empty, 1, 1)[0]
def test_delete_controlfield(self):
"""bibrecord - deleting controlfield"""
bibrecord.record_delete_field(self.rec, "001", " ", " ")
self.assertEqual(bibrecord.record_get_field_values(self.rec, "001", " ", " ", " "),
[])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "b"),
['editor'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "2", "a"),
['On the foo and bar2'])
def test_delete_datafield(self):
"""bibrecord - deleting datafield"""
bibrecord.record_delete_field(self.rec, "100", " ", " ")
self.assertEqual(bibrecord.record_get_field_values(self.rec, "001", " ", " ", ""),
['33'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "b"),
[])
bibrecord.record_delete_field(self.rec, "245", " ", " ")
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "1", "a"),
['On the foo and bar1'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "2", "a"),
['On the foo and bar2'])
bibrecord.record_delete_field(self.rec, "245", " ", "2")
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "1", "a"),
['On the foo and bar1'])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "2", "a"),
[])
def test_add_delete_add_field_to_empty_record(self):
"""bibrecord - adding, deleting, and adding back a field to an empty record"""
field_position_global_1 = bibrecord.record_add_field(self.rec_empty, "003",
controlfield_value="SzGeCERN")
self.assertEqual(field_position_global_1, 1)
self.assertEqual(bibrecord.record_get_field_values(self.rec_empty, "003", " ", " ", ""),
['SzGeCERN'])
bibrecord.record_delete_field(self.rec_empty, "003", " ", " ")
self.assertEqual(bibrecord.record_get_field_values(self.rec_empty, "003", " ", " ", ""),
[])
field_position_global_1 = bibrecord.record_add_field(self.rec_empty, "003",
controlfield_value="SzGeCERN2")
self.assertEqual(field_position_global_1, 1)
self.assertEqual(bibrecord.record_get_field_values(self.rec_empty, "003", " ", " ", ""),
['SzGeCERN2'])
class BibRecordDeleteFieldFromTest(unittest.TestCase):
""" bibrecord - testing field deletion from position"""
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe1, John</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_delete_field_from(self):
"""bibrecord - deleting field from position"""
bibrecord.record_delete_field(self.rec, "100", field_position_global=4)
self.assertEqual(self.rec['100'], [([('a', 'Doe1, John')], ' ', ' ', '', 3)])
bibrecord.record_delete_field(self.rec, "100", field_position_global=3)
self.failIf(self.rec.has_key('100'))
bibrecord.record_delete_field(self.rec, "001", field_position_global=1)
bibrecord.record_delete_field(self.rec, "245", field_position_global=6)
self.failIf(self.rec.has_key('001'))
self.assertEqual(self.rec['245'], [([('a', 'On the foo and bar1')], ' ', '1', '', 5)])
# Some crash tests
bibrecord.record_delete_field(self.rec, '999', field_position_global=1)
bibrecord.record_delete_field(self.rec, '245', field_position_global=999)
class BibRecordAddSubfieldIntoTest(unittest.TestCase):
""" bibrecord - testing subfield addition """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_add_subfield_into(self):
"""bibrecord - adding subfield into position"""
bibrecord.record_add_subfield_into(self.rec, "100", "b", "Samekniv",
field_position_global=3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "b"),
['editor', 'Samekniv'])
bibrecord.record_add_subfield_into(self.rec, "245", "x", "Elgokse",
field_position_global=4)
bibrecord.record_add_subfield_into(self.rec, "245", "x", "Fiskeflue",
subfield_position=0, field_position_global=4)
bibrecord.record_add_subfield_into(self.rec, "245", "z", "Ulriken",
subfield_position=2, field_position_global=4)
bibrecord.record_add_subfield_into(self.rec, "245", "z",
"Stortinget", subfield_position=999, field_position_global=4)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "1", "%"),
['Fiskeflue', 'On the foo and bar1', 'Ulriken', 'Elgokse', 'Stortinget'])
# Some crash tests
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_add_subfield_into, self.rec, "187", "x", "Crash",
field_position_global=1)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_add_subfield_into, self.rec, "245", "x", "Crash",
field_position_global=999)
class BibRecordModifyControlfieldTest(unittest.TestCase):
""" bibrecord - testing controlfield modification """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<controlfield tag="005">A Foo's Tale</controlfield>
<controlfield tag="008">Skeech Skeech</controlfield>
<controlfield tag="008">Whoop Whoop</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_modify_controlfield(self):
"""bibrecord - modify controlfield"""
bibrecord.record_modify_controlfield(self.rec, "001", "34",
field_position_global=1)
bibrecord.record_modify_controlfield(self.rec, "008", "Foo Foo",
field_position_global=3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "001"), ["34"])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "005"), ["A Foo's Tale"])
self.assertEqual(bibrecord.record_get_field_values(self.rec, "008"), ["Foo Foo", "Whoop Whoop"])
# Some crash tests
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_modify_controlfield, self.rec, "187", "Crash",
field_position_global=1)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_modify_controlfield, self.rec, "008", "Test",
field_position_global=10)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_modify_controlfield, self.rec, "245", "Burn",
field_position_global=5)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "2", "%"),
["On the foo and bar2"])
class BibRecordModifySubfieldTest(unittest.TestCase):
""" bibrecord - testing subfield modification """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
<subfield code="b">On writing unit tests</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_modify_subfield(self):
"""bibrecord - modify subfield"""
bibrecord.record_modify_subfield(self.rec, "245", "a", "Holmenkollen",
0, field_position_global=4)
bibrecord.record_modify_subfield(self.rec, "245", "x", "Brann", 1,
field_position_global=4)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "245", " ", "1", "%"),
['Holmenkollen', 'Brann'])
# Some crash tests
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_modify_subfield, self.rec, "187", "x", "Crash", 0,
field_position_global=1)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_modify_subfield, self.rec, "245", "x", "Burn", 1,
field_position_global=999)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_modify_subfield, self.rec, "245", "a", "Burn",
999, field_position_global=4)
class BibRecordDeleteSubfieldFromTest(unittest.TestCase):
""" bibrecord - testing subfield deletion """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
<subfield code="z">Skal vi danse?</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_delete_subfield_from(self):
"""bibrecord - delete subfield from position"""
bibrecord.record_delete_subfield_from(self.rec, "100", 2,
field_position_global=3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "z"),
[])
bibrecord.record_delete_subfield_from(self.rec, "100", 0,
field_position_global=3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "%"),
['editor'])
bibrecord.record_delete_subfield_from(self.rec, "100", 0,
field_position_global=3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "%"),
[])
# Some crash tests
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_delete_subfield_from, self.rec, "187", 0,
field_position_global=1)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_delete_subfield_from, self.rec, "245", 0,
field_position_global=999)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_delete_subfield_from, self.rec, "245", 999,
field_position_global=4)
class BibRecordDeleteSubfieldTest(unittest.TestCase):
""" bibrecord - testing subfield deletion """
def setUp(self):
"""Initialize stuff"""
self.xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
<subfield code="z">Skal vi danse?</subfield>
<subfield code="a">Doe3, Zbigniew</subfield>
<subfield code="d">Doe4, Joachim</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="2">
<subfield code="a">On the foo and bar2</subfield>
</datafield>
<datafield tag="246" ind1="1" ind2="2">
<subfield code="c">On the foo and bar1</subfield>
</datafield>
<datafield tag="246" ind1="1" ind2="2">
<subfield code="c">On the foo and bar2</subfield>
</datafield>
</record>
"""
def test_simple_removals(self):
""" bibrecord - delete subfield by its code"""
# testing a simple removals where all the fields are removed
rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
bibrecord.record_delete_subfield(rec, "041", "b") # nothing should change
self.assertEqual(rec["041"][0][0], [("a", "eng")])
bibrecord.record_delete_subfield(rec, "041", "a")
self.assertEqual(rec["041"][0][0], [])
def test_indices_important(self):
""" bibrecord - delete subfield where indices are important"""
rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
bibrecord.record_delete_subfield(rec, "245", "a", " ", "1")
self.assertEqual(rec["245"][0][0], [])
self.assertEqual(rec["245"][1][0], [("a", "On the foo and bar2")])
bibrecord.record_delete_subfield(rec, "245", "a", " ", "2")
self.assertEqual(rec["245"][1][0], [])
def test_remove_some(self):
""" bibrecord - delete subfield when some should be preserved and some removed"""
rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
bibrecord.record_delete_subfield(rec, "100", "a", " ", " ")
self.assertEqual(rec["100"][0][0], [("b", "editor"), ("z", "Skal vi danse?"), ("d", "Doe4, Joachim")])
def test_more_fields(self):
""" bibrecord - delete subfield where more fits criteria"""
rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
bibrecord.record_delete_subfield(rec, "246", "c", "1", "2")
self.assertEqual(rec["246"][1][0], [])
self.assertEqual(rec["246"][0][0], [])
def test_nonexisting_removals(self):
""" bibrecord - delete subfield that does not exist """
rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
# further preparation
bibrecord.record_delete_subfield(rec, "100", "a", " ", " ")
self.assertEqual(rec["100"][0][0], [("b", "editor"), ("z", "Skal vi danse?"), ("d", "Doe4, Joachim")])
#the real tests begin
# 1) removing the subfield from an empty list of subfields
bibrecord.record_delete_subfield(rec, "246", "c", "1", "2")
self.assertEqual(rec["246"][1][0], [])
self.assertEqual(rec["246"][0][0], [])
bibrecord.record_delete_subfield(rec, "246", "8", "1", "2")
self.assertEqual(rec["246"][1][0], [])
self.assertEqual(rec["246"][0][0], [])
# 2) removing a subfield from a field that has some subfields but none has an appropriate code
bibrecord.record_delete_subfield(rec, "100", "a", " ", " ")
self.assertEqual(rec["100"][0][0], [("b", "editor"), ("z", "Skal vi danse?"), ("d", "Doe4, Joachim")])
bibrecord.record_delete_subfield(rec, "100", "e", " ", " ")
self.assertEqual(rec["100"][0][0], [("b", "editor"), ("z", "Skal vi danse?"), ("d", "Doe4, Joachim")])
class BibRecordMoveSubfieldTest(unittest.TestCase):
""" bibrecord - testing subfield moving """
def setUp(self):
"""Initialize stuff"""
xml_example_record = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Doe2, John</subfield>
<subfield code="b">editor</subfield>
<subfield code="c">fisk</subfield>
<subfield code="d">eple</subfield>
<subfield code="e">hammer</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2="1">
<subfield code="a">On the foo and bar1</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml_example_record, 1, 1)[0]
def test_move_subfield(self):
"""bibrecord - move subfields"""
bibrecord.record_move_subfield(self.rec, "100", 2, 4,
field_position_global=3)
bibrecord.record_move_subfield(self.rec, "100", 1, 0,
field_position_global=3)
bibrecord.record_move_subfield(self.rec, "100", 2, 999,
field_position_global=3)
self.assertEqual(bibrecord.record_get_field_values(self.rec, "100", " ", " ", "%"),
['editor', 'Doe2, John', 'hammer', 'fisk', 'eple'])
# Some crash tests
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_move_subfield, self.rec, "187", 0, 1,
field_position_global=3)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_move_subfield, self.rec, "100", 1, 0,
field_position_global=999)
self.assertRaises(bibrecord.InvenioBibRecordFieldError,
bibrecord.record_move_subfield, self.rec, "100", 999, 0,
field_position_global=3)
class BibRecordSpecialTagParsingTest(unittest.TestCase):
""" bibrecord - parsing special tags (FMT, FFT)"""
def setUp(self):
"""setting up example records"""
self.xml_example_record_with_fmt = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="FMT" ind1=" " ind2=" ">
<subfield code="f">HB</subfield>
<subfield code="g">Let us see if this gets inserted well.</subfield>
</datafield>
</record>
"""
self.xml_example_record_with_fft = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="FFT" ind1=" " ind2=" ">
<subfield code="a">file:///foo.pdf</subfield>
<subfield code="a">http://bar.com/baz.ps.gz</subfield>
</datafield>
</record>
"""
self.xml_example_record_with_xyz = """
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="041" ind1=" " ind2=" ">
<subfield code="a">eng</subfield>
</datafield>
<datafield tag="XYZ" ind1=" " ind2=" ">
<subfield code="f">HB</subfield>
<subfield code="g">Let us see if this gets inserted well.</subfield>
</datafield>
</record>
"""
def test_parsing_file_containing_fmt_special_tag_with_correcting(self):
"""bibrecord - parsing special FMT tag, correcting on"""
rec = bibrecord.create_record(self.xml_example_record_with_fmt, 1, 1)[0]
self.assertEqual(rec,
{u'001': [([], " ", " ", '33', 1)],
'FMT': [([('f', 'HB'), ('g', 'Let us see if this gets inserted well.')], " ", " ", "", 3)],
'041': [([('a', 'eng')], " ", " ", "", 2)]})
self.assertEqual(bibrecord.record_get_field_values(rec, "041", " ", " ", "a"),
['eng'])
self.assertEqual(bibrecord.record_get_field_values(rec, "FMT", " ", " ", "f"),
['HB'])
self.assertEqual(bibrecord.record_get_field_values(rec, "FMT", " ", " ", "g"),
['Let us see if this gets inserted well.'])
def test_parsing_file_containing_fmt_special_tag_without_correcting(self):
"""bibrecord - parsing special FMT tag, correcting off"""
rec = bibrecord.create_record(self.xml_example_record_with_fmt, 1, 0)[0]
self.assertEqual(rec,
{u'001': [([], " ", " ", '33', 1)],
'FMT': [([('f', 'HB'), ('g', 'Let us see if this gets inserted well.')], " ", " ", "", 3)],
'041': [([('a', 'eng')], " ", " ", "", 2)]})
self.assertEqual(bibrecord.record_get_field_values(rec, "041", " ", " ", "a"),
['eng'])
self.assertEqual(bibrecord.record_get_field_values(rec, "FMT", " ", " ", "f"),
['HB'])
self.assertEqual(bibrecord.record_get_field_values(rec, "FMT", " ", " ", "g"),
['Let us see if this gets inserted well.'])
def test_parsing_file_containing_fft_special_tag_with_correcting(self):
"""bibrecord - parsing special FFT tag, correcting on"""
rec = bibrecord.create_record(self.xml_example_record_with_fft, 1, 1)[0]
self.assertEqual(rec,
{u'001': [([], " ", " ", '33', 1)],
'FFT': [([('a', 'file:///foo.pdf'), ('a', 'http://bar.com/baz.ps.gz')], " ", " ", "", 3)],
'041': [([('a', 'eng')], " ", " ", "", 2)]})
self.assertEqual(bibrecord.record_get_field_values(rec, "041", " ", " ", "a"),
['eng'])
self.assertEqual(bibrecord.record_get_field_values(rec, "FFT", " ", " ", "a"),
['file:///foo.pdf', 'http://bar.com/baz.ps.gz'])
def test_parsing_file_containing_fft_special_tag_without_correcting(self):
"""bibrecord - parsing special FFT tag, correcting off"""
rec = bibrecord.create_record(self.xml_example_record_with_fft, 1, 0)[0]
self.assertEqual(rec,
{u'001': [([], " ", " ", '33', 1)],
'FFT': [([('a', 'file:///foo.pdf'), ('a', 'http://bar.com/baz.ps.gz')], " ", " ", "", 3)],
'041': [([('a', 'eng')], " ", " ", "", 2)]})
self.assertEqual(bibrecord.record_get_field_values(rec, "041", " ", " ", "a"),
['eng'])
self.assertEqual(bibrecord.record_get_field_values(rec, "FFT", " ", " ", "a"),
['file:///foo.pdf', 'http://bar.com/baz.ps.gz'])
def test_parsing_file_containing_xyz_special_tag_with_correcting(self):
"""bibrecord - parsing unrecognized special XYZ tag, correcting on"""
# XYZ should not get accepted when correcting is on; should get changed to 000
rec = bibrecord.create_record(self.xml_example_record_with_xyz, 1, 1)[0]
self.assertEqual(rec,
{u'001': [([], " ", " ", '33', 1)],
'000': [([('f', 'HB'), ('g', 'Let us see if this gets inserted well.')], " ", " ", "", 3)],
'041': [([('a', 'eng')], " ", " ", "", 2)]})
self.assertEqual(bibrecord.record_get_field_values(rec, "041", " ", " ", "a"),
['eng'])
self.assertEqual(bibrecord.record_get_field_values(rec, "XYZ", " ", " ", "f"),
[])
self.assertEqual(bibrecord.record_get_field_values(rec, "XYZ", " ", " ", "g"),
[])
self.assertEqual(bibrecord.record_get_field_values(rec, "000", " ", " ", "f"),
['HB'])
self.assertEqual(bibrecord.record_get_field_values(rec, "000", " ", " ", "g"),
['Let us see if this gets inserted well.'])
def test_parsing_file_containing_xyz_special_tag_without_correcting(self):
"""bibrecord - parsing unrecognized special XYZ tag, correcting off"""
# XYZ should get accepted without correcting
rec = bibrecord.create_record(self.xml_example_record_with_xyz, 1, 0)[0]
self.assertEqual(rec,
{u'001': [([], " ", " ", '33', 1)],
'XYZ': [([('f', 'HB'), ('g', 'Let us see if this gets inserted well.')], " ", " ", "", 3)],
'041': [([('a', 'eng')], " ", " ", "", 2)]})
self.assertEqual(bibrecord.record_get_field_values(rec, "041", " ", " ", "a"),
['eng'])
self.assertEqual(bibrecord.record_get_field_values(rec, "XYZ", " ", " ", "f"),
['HB'])
self.assertEqual(bibrecord.record_get_field_values(rec, "XYZ", " ", " ", "g"),
['Let us see if this gets inserted well.'])
class BibRecordPrintingTest(unittest.TestCase):
""" bibrecord - testing for printing record """
def setUp(self):
"""Initialize stuff"""
self.xml_example_record = """
<record>
<controlfield tag="001">81</controlfield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">TEST-ARTICLE-2006-001</subfield>
</datafield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">ARTICLE-2006-001</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">Test ti</subfield>
</datafield>
</record>"""
self.xml_example_record_short = """
<record>
<controlfield tag="001">81</controlfield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">TEST-ARTICLE-2006-001</subfield>
</datafield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">ARTICLE-2006-001</subfield>
</datafield>
</record>"""
self.xml_example_multi_records = """
<record>
<controlfield tag="001">81</controlfield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">TEST-ARTICLE-2006-001</subfield>
</datafield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">ARTICLE-2006-001</subfield>
</datafield>
<datafield tag="245" ind1=" " ind2=" ">
<subfield code="a">Test ti</subfield>
</datafield>
</record>
<record>
<controlfield tag="001">82</controlfield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Author, t</subfield>
</datafield>
</record>"""
self.xml_example_multi_records_short = """
<record>
<controlfield tag="001">81</controlfield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">TEST-ARTICLE-2006-001</subfield>
</datafield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">ARTICLE-2006-001</subfield>
</datafield>
</record>
<record>
<controlfield tag="001">82</controlfield>
</record>"""
def test_record_xml_output(self):
"""bibrecord - xml output"""
rec = bibrecord.create_record(self.xml_example_record, 1, 1)[0]
rec_short = bibrecord.create_record(self.xml_example_record_short, 1, 1)[0]
self.assertEqual(bibrecord.create_record(bibrecord.record_xml_output(rec, tags=[]), 1, 1)[0], rec)
self.assertEqual(bibrecord.create_record(bibrecord.record_xml_output(rec, tags=["001", "037"]), 1, 1)[0], rec_short)
self.assertEqual(bibrecord.create_record(bibrecord.record_xml_output(rec, tags=["037"]), 1, 1)[0], rec_short)
class BibRecordCreateFieldTest(unittest.TestCase):
""" bibrecord - testing for creating field """
def test_create_valid_field(self):
"""bibrecord - create and check a valid field"""
bibrecord.create_field()
bibrecord.create_field([('a', 'testa'), ('b', 'testb')], '2', 'n',
'controlfield', 15)
def test_invalid_field_raises_exception(self):
"""bibrecord - exception raised when creating an invalid field"""
# Invalid subfields.
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, 'subfields', '1', '2', 'controlfield', 10)
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, ('1', 'value'), '1', '2', 'controlfield', 10)
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, [('value')], '1', '2', 'controlfield', 10)
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, [('1', 'value', '2')], '1', '2', 'controlfield', 10)
# Invalid indicators.
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, [], 1, '2', 'controlfield', 10)
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, [], '1', 2, 'controlfield', 10)
# Invalid controlfield value
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, [], '1', '2', 13, 10)
# Invalid global position
self.assertRaises(bibrecord_config.InvenioBibRecordFieldError,
bibrecord.create_field, [], '1', '2', 'controlfield', 'position')
def test_compare_fields(self):
"""bibrecord - compare fields"""
# Identical
field0 = ([('a', 'test')], '1', '2', '', 0)
field1 = ([('a', 'test')], '1', '2', '', 3)
self.assertEqual(True,
bibrecord._compare_fields(field0, field1, strict=True))
self.assertEqual(True,
bibrecord._compare_fields(field0, field1, strict=False))
# Order of the subfields changed.
field0 = ([('a', 'testa'), ('b', 'testb')], '1', '2', '', 0)
field1 = ([('b', 'testb'), ('a', 'testa')], '1', '2', '', 3)
self.assertEqual(False,
bibrecord._compare_fields(field0, field1, strict=True))
self.assertEqual(True,
bibrecord._compare_fields(field0, field1, strict=False))
# Different
field0 = ([], '3', '2', '', 0)
field1 = ([], '1', '2', '', 3)
self.assertEqual(False,
bibrecord._compare_fields(field0, field1, strict=True))
self.assertEqual(False,
bibrecord._compare_fields(field0, field1, strict=False))
class BibRecordFindFieldTest(unittest.TestCase):
""" bibrecord - testing for finding field """
def setUp(self):
"""Initialize stuff"""
xml = """
<record>
<controlfield tag="001">81</controlfield>
<datafield tag="037" ind1=" " ind2=" ">
<subfield code="a">TEST-ARTICLE-2006-001</subfield>
<subfield code="b">ARTICLE-2007-001</subfield>
</datafield>
</record>
"""
self.rec = bibrecord.create_record(xml)[0]
self.field0 = self.rec['001'][0]
self.field1 = self.rec['037'][0]
self.field2 = (
[self.field1[0][1], self.field1[0][0]],
self.field1[1],
self.field1[2],
self.field1[3],
self.field1[4],
)
def test_finding_field_strict(self):
"""bibrecord - test finding field strict"""
self.assertEqual((1, 0),
bibrecord.record_find_field(self.rec, '001', self.field0,
strict=True))
self.assertEqual((2, 0),
bibrecord.record_find_field(self.rec, '037', self.field1,
strict=True))
self.assertEqual((None, None),
bibrecord.record_find_field(self.rec, '037', self.field2,
strict=True))
def test_finding_field_loose(self):
"""bibrecord - test finding field loose"""
self.assertEqual((1, 0),
bibrecord.record_find_field(self.rec, '001', self.field0,
strict=False))
self.assertEqual((2, 0),
bibrecord.record_find_field(self.rec, '037', self.field1,
strict=False))
self.assertEqual((2, 0),
bibrecord.record_find_field(self.rec, '037', self.field2,
strict=False))
class BibRecordSingletonTest(unittest.TestCase):
""" bibrecord - testing singleton removal """
def setUp(self):
"""Initialize stuff"""
self.xml = """<collection>
<record>
<controlfield tag="001">33</controlfield>
<controlfield tag="002" />
<datafield tag="99" ind1=" " ind2=" "/>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a" />
</datafield>
<datafield tag="100" ind1=" " ind2=" ">
<subfield code="a">Some value</subfield>
</datafield>
<tagname />
</record>
<record />
<collection>"""
self.rec_expected = {
'001': [([], ' ', ' ', '33', 1)],
'100': [([('a', 'Some value')], ' ', ' ', '', 2)],
}
if parser_minidom_available:
def test_singleton_removal_minidom(self):
"""bibrecord - enforcing singleton removal with minidom"""
rec = bibrecord.create_records(self.xml, verbose=1,
correct=1, parser='minidom',
keep_singletons=False)[0][0]
self.assertEqual(rec, self.rec_expected)
if parser_4suite_available:
def test_singleton_removal_4suite(self):
"""bibrecord - enforcing singleton removal with 4suite"""
rec = bibrecord.create_records(self.xml, verbose=1,
correct=1, parser='4suite',
keep_singletons=False)[0][0]
self.assertEqual(rec, self.rec_expected)
if parser_pyrxp_available:
def test_singleton_removal_pyrxp(self):
"""bibrecord - enforcing singleton removal with pyrxp"""
rec = bibrecord.create_records(self.xml, verbose=1,
correct=1, parser='pyrxp',
keep_singletons=False)[0][0]
self.assertEqual(rec, self.rec_expected)
class BibRecordNumCharRefTest(unittest.TestCase):
""" bibrecord - testing numerical character reference expansion"""
def setUp(self):
"""Initialize stuff"""
self.xml = """<?xml version="1.0" encoding="UTF-8"?>
<record>
<controlfield tag="001">33</controlfield>
<datafield tag="123" ind1=" " ind2=" ">
<subfield code="a">Σ &amp; &#931;</subfield>
<subfield code="a">use &amp;amp; in XML</subfield>
</datafield>
</record>"""
self.rec_expected = {
'001': [([], ' ', ' ', '33', 1)],
'123': [([('a', '\xce\xa3 & \xce\xa3'), ('a', 'use &amp; in XML'),], ' ', ' ', '', 2)],
}
if parser_minidom_available:
def test_numcharref_expansion_minidom(self):
"""bibrecord - numcharref expansion with minidom"""
rec = bibrecord.create_records(self.xml, verbose=1,
correct=1, parser='minidom')[0][0]
self.assertEqual(rec, self.rec_expected)
if parser_4suite_available:
def test_numcharref_expansion_4suite(self):
"""bibrecord - numcharref expansion with 4suite"""
rec = bibrecord.create_records(self.xml, verbose=1,
correct=1, parser='4suite')[0][0]
self.assertEqual(rec, self.rec_expected)
if parser_pyrxp_available:
def test_numcharref_expansion_pyrxp(self):
"""bibrecord - but *no* numcharref expansion with pyrxp (see notes)
FIXME: pyRXP does not seem to like num char ref entities,
so this test is mostly left here in a TDD style in order
to remind us of this fact. If we want to fix this
situation, then we should probably use pyRXPU that uses
Unicode strings internally, hence it is num char ref
friendly. Maybe we should use pyRXPU by default, if
performance is acceptable, or maybe we should introduce a
flag to govern this behaviour.
"""
rec = bibrecord.create_records(self.xml, verbose=1,
correct=1, parser='pyrxp')[0][0]
#self.assertEqual(rec, self.rec_expected)
self.assertEqual(rec, None)
TEST_SUITE = make_test_suite(
BibRecordSuccessTest,
BibRecordParsersTest,
BibRecordBadInputTreatmentTest,
BibRecordGettingFieldValuesTest,
BibRecordGettingFieldValuesViaWildcardsTest,
BibRecordAddFieldTest,
BibRecordDeleteFieldTest,
BibRecordManageMultipleFieldsTest,
BibRecordDeleteFieldFromTest,
BibRecordAddSubfieldIntoTest,
BibRecordModifyControlfieldTest,
BibRecordModifySubfieldTest,
BibRecordDeleteSubfieldFromTest,
BibRecordMoveSubfieldTest,
BibRecordAccentedUnicodeLettersTest,
BibRecordSpecialTagParsingTest,
BibRecordPrintingTest,
BibRecordCreateFieldTest,
BibRecordFindFieldTest,
BibRecordDeleteSubfieldTest,
BibRecordSingletonTest,
BibRecordNumCharRefTest
)
if __name__ == '__main__':
run_test_suite(TEST_SUITE)

Event Timeline

c4science · Help