import csb.test as test
from csb.bio.io import ClansParser
from csb.bio.io.clans import Clans, ClansEntry, ClansParams, ClansSeqgroup,\
Color, ClansEntryCollection, ClansSeqgroupCollection, DuplicateEntryError,\
DuplicateEntryNameError
@test.unit
class TestClansColor(test.Case):
def setUp(self):
super(TestClansColor, self).setUp()
def testColorInit(self):
color = Color()
self.assertEqual(color.r, 0)
self.assertEqual(color.g, 0)
self.assertEqual(color.b, 0)
def testColorSetter(self):
color = Color()
for color_name in ('r', 'g', 'b'):
self.assertRaises(ValueError, color.__setattr__, color_name, -1)
self.assertRaises(ValueError, color.__setattr__, color_name, 256)
def testParseClansColorWithCorrectInput(self):
correct_input = '83;92;3'
color = Color.from_string(correct_input)
self.assertEqual(color.r, 83)
self.assertEqual(color.g, 92)
self.assertEqual(color.b, 3)
def testParseClansColorWithWrongInput(self):
color = Color()
wrong_input_1 = (83, 92, 3)
self.assertRaises(TypeError,
color.from_string, wrong_input_1)
wrong_input_2 = '83;92;3;'
self.assertRaises(ValueError, color.from_string, wrong_input_2)
wrong_input_3 = '83;92'
self.assertRaises(ValueError, color.from_string, wrong_input_3)
def testToClansColor(self):
color = Color()
self.assertEqual(color.to_clans_color(), '0;0;0;255')
testValues = (83, 92, 3, 87)
color.r = testValues[0]
color.g = testValues[1]
color.b = testValues[2]
color.a = testValues[3]
self.assertEqual(color.to_clans_color(),
';'.join(map(str, testValues)))
@test.functional
class TestClansParams(test.Case):
def setUp(self):
super(TestClansParams, self).setUp()
def testInstatiation(self):
cp = ClansParams()
for attribute_name, default_value in cp._DEFAULTS.items():
if attribute_name == 'colors':
continue
self.assertEqual(cp.__getattribute__(attribute_name),
default_value)
def testUnknownParamFail(self):
self.assertRaises(KeyError, ClansParams, **{'unknownParam': True})
def testForbiddenAssignments(self):
self.assertRaises(ValueError, ClansParams, **{'attfactor': 'a'})
self.assertRaises(ValueError, ClansParams, **{'attvalpow': 'a'})
self.assertRaises(ValueError, ClansParams, **{'avgfoldchange': 'a'})
self.assertRaises(ValueError, ClansParams, **{'blastpath': 3})
self.assertRaises(ValueError, ClansParams, **{'cluster2d': 'a'})
self.assertRaises(ValueError, ClansParams, **{'colors': 'a'})
self.assertRaises(ValueError, ClansParams, **{'complexatt': 'a'})
self.assertRaises(ValueError, ClansParams, **{'cooling': 'a'})
self.assertRaises(ValueError, ClansParams, **{'currcool': 'a'})
self.assertRaises(ValueError, ClansParams, **{'dampening': 'a'})
self.assertRaises(ValueError, ClansParams, **{'dotsize': 'a'})
self.assertRaises(ValueError, ClansParams, **{'formatdbpath': 3})
self.assertRaises(ValueError, ClansParams, **{'groupsize': 'a'})
self.assertRaises(ValueError, ClansParams, **{'maxmove': 'a'})
self.assertRaises(ValueError, ClansParams, **{'minattract': 'a'})
self.assertRaises(ValueError, ClansParams, **{'ovalsize': 'a'})
self.assertRaises(ValueError, ClansParams, **{'pval': 'a'})
self.assertRaises(ValueError, ClansParams, **{'repfactor': 'a'})
self.assertRaises(ValueError, ClansParams, **{'repvalpow': 'a'})
self.assertRaises(ValueError, ClansParams, **{'showinfo': 'a'})
self.assertRaises(ValueError, ClansParams, **{'usefoldchange': 'a'})
self.assertRaises(ValueError, ClansParams, **{'usescval': 'a'})
self.assertRaises(ValueError, ClansParams, **{'zoom': 'a'})
@test.functional
class TestClans(test.Case):
def setUp(self):
super(TestClans, self).setUp()
def testClansInit(self):
'''
Test creating an empty L{Clans} instance.
'''
c = Clans()
param_names = ['attfactor', 'attvalpow', 'avgfoldchange', 'blastpath',
'cluster2d', 'colors', 'complexatt', 'cooling',
'currcool', 'dampening', 'dotsize', 'formatdbpath',
'groupsize', 'maxmove', 'minattract', 'ovalsize',
'pval', 'repfactor', 'repvalpow', 'showinfo',
'usefoldchange', 'usescval', 'zoom']
for param_name in param_names:
self.assertTrue(hasattr(c.params, param_name))
self.assertEqual(c.filename, None)
self.assertEqual(c.rotmtx.shape, (3, 3))
self.assertEqual(len(c.entries), 0)
self.assertEqual(len(c.seqgroups), 0)
self.assertTrue(isinstance(c.entries, ClansEntryCollection))
self.assertTrue(isinstance(c.seqgroups, ClansSeqgroupCollection))
def testClansEntryAddingAndSorting(self):
c = Clans()
names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
shuffled_names = ['g', 'f', 'b', 'd', 'e', 'c', 'a']
for name in shuffled_names:
c.add_entry(ClansEntry(name=name))
c.sort()
for i, e in enumerate(c):
self.assertEqual(e.name, names[i])
def testClansEntrySortingWithCustomKeyFunction(self):
c = Clans()
sequences = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
shuffled_sequences = ['g', 'f', 'b', 'd', 'e', 'c', 'a']
for i, sequence in enumerate(sequences):
c.add_entry(ClansEntry(name=str(i), seq=shuffled_sequences[i]))
custom_key_function = lambda e: e.seq # sort by sequence instead of name
c.sort(key=custom_key_function)
for i, e in enumerate(c):
self.assertEqual(e.seq, sequences[i])
def testGetEntry(self):
c = Clans()
## get non-existant entry from empty clans instance
self.assertRaises(ValueError, c.get_entry, 'a')
names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
entries = [ClansEntry(name=name) for name in names]
[c.add_entry(e) for e in entries]
## check whether entries fetched by name match those created
for i, name in enumerate(names):
self.assertEqual(c.get_entry(name), entries[i])
## check pedantic flag for duplicate name='a' entries
c.add_entry(ClansEntry(name='a'))
self.assertTrue(c.get_entry('a', False).name == 'a')
self.assertRaises(DuplicateEntryNameError, c.get_entry, 'a', True)
def testDuplicateEntryError(self):
c = Clans()
e = ClansEntry(name='a', seq='A', coords=(1., 1., 1.))
c.add_entry(e)
c.add_entry(e)
original_length = len(c)
self.assertRaises(DuplicateEntryError, c._update_index)
self.assertEqual(original_length, len(c))
@test.functional
class TestClansSeqgroup(test.Case):
def setUp(self):
super(TestClansSeqgroup, self).setUp()
def testInit(self):
sg = ClansSeqgroup()
self.assertTrue(sg.is_empty())
def testAddingAndRemovingSeqgroups(self):
c = Clans()
names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
for i, name in enumerate(names):
c.add_group(ClansSeqgroup(name=name))
self.assertEqual(len(c.seqgroups), i + 1)
removed = 0
while len(c.seqgroups) != 0:
c.remove_group(c.seqgroups[-1])
removed += 1
self.assertEqual(removed, len(names))
self.assertEqual(len(c.seqgroups), 0)
testGroup = ClansSeqgroup()
self.assertRaises(TypeError, testGroup.add, 23)
self.assertRaises(TypeError, testGroup.remove, 23)
def testAppendingSeqgroupsFromOtherInstance(self):
source = Clans()
source_entry1 = ClansEntry(name='X', seq='S')
source_entry2 = ClansEntry(name='A', seq='S')
source.add_entry(source_entry1)
source.add_entry(source_entry2)
seqgroup_names_to_transfer = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
for i, name in enumerate(seqgroup_names_to_transfer):
sg = ClansSeqgroup(name=name)
sg.add(source_entry1)
source.add_group(sg)
seqgroup_names_to_omit = ['x', 'y', 'z']
for i, name in enumerate(seqgroup_names_to_omit):
sg = ClansSeqgroup(name=name)
sg.add(source_entry2)
source.add_group(sg)
target = Clans()
# different seq is tolerated, only name identity is checked
target_entry = ClansEntry(name='X', seq='Q')
target.add_entry(target_entry)
self.assertEqual(source[0].name, target[0].name)
target.append_groups_from(source)
## each group should have exactly one member
self.assertEqual(len(set([len(group.members) for group in target.seqgroups])), 1)
## all groups of seqgroup_names should have been transferred
self.assertEqual(len(target.seqgroups), len(seqgroup_names_to_transfer))
self.assertEqual([group.name for group in target.seqgroups], seqgroup_names_to_transfer)
## the ones from seqgroup_names_to_omit should not be there
self.assertEqual(len([group.name for group in target.seqgroups
if group.name in seqgroup_names_to_omit]), 0)
def testAddingClansEntries(self):
c = Clans()
sg = ClansSeqgroup()
c.add_group(sg)
e = ClansEntry()
c.add_entry(e)
## add entry to seqgroup
sg.add(e)
self.assertEqual(len(sg), 1)
self.assertEqual(len(e.groups), 1)
## adding the same entry is forbidden
self.assertRaises(ValueError, sg.add, e)
## adding s.th. else than a ClansEntry
self.assertRaises(TypeError, sg.add, 23)
def testRemovingClansEntries(self):
c = Clans()
sg = ClansSeqgroup()
c.add_group(sg)
e = ClansEntry()
c.add_entry(e)
sg.add(e)
sg.remove(e)
self.assertEqual(len(sg), 0)
self.assertEqual(len(e.groups), 0)
self.assertRaises(TypeError, sg.remove, 23)
self.assertRaises(ValueError, sg.remove, e)
@test.functional
class TestClansParser(test.Case):
def setUp(self):
super(TestClansParser, self).setUp()
self.filename = self.config.getTestFile('out.clans')
def testPrematureGetter(self):
'''
Test whether the premature (before parsing) access to clans_instance is
properly handled.
'''
cp = ClansParser()
self.assertRaises(ValueError, cp.__getattribute__, 'clans_instance')
def testParseFile(self):
'''
Test parsing of a small dummy file with known values
'''
from numpy import array
cp = ClansParser()
self.clans_instance = cp.parse_file(self.filename)
self.assertEqual(len(self.clans_instance), 41)
self.assertRaises(IndexError, self.clans_instance.__getitem__, 41)
correct_rotmtx = array([[0.75614862, 0.65439992, 0.],
[-0.65439992, 0.75614862, 0.],
[0., 0., 1.]])
self.assertEqual(self.clans_instance.rotmtx.shape, (3, 3))
self.assertTrue(
(self.clans_instance.rotmtx - correct_rotmtx < 1e-6).all())
self.assertEqual(len(self.clans_instance.seqgroups), 4)
seqgroup_names = ('insect hypoth. protein (2 copies, C term)',
'allergens >= xyz',
'empty group WITH terminal semicolon in numbers line',
'empty group WITHOUT terminal semicolon in numbers line')
seqgroup_sizes = (20, 17, 0, 0)
for i, seqgroup in enumerate(self.clans_instance.seqgroups):
self.assertEqual(len(seqgroup), seqgroup_sizes[i])
self.assertEqual(seqgroup.name, seqgroup_names[i])
@test.functional
class TestClansFileWriter(test.Case):
def setUp(self):
super(TestClansFileWriter, self).setUp()
self.filename = self.config.getTestFile('out.clans')
self.temp = self.config.getTempStream()
def testWrittenIsIdenticalToOriginal(self):
cp = ClansParser()
clans_instance = cp.parse_file(self.filename)
clans_instance.write(self.temp.name)
self.temp.flush()
with open(self.filename) as original_file:
original_lines = original_file.readlines()
with open(self.temp.name) as written_file:
written_lines = written_file.readlines()
self.assertEqual(len(original_lines), len(written_lines))
in_hsps = False
start_tag_hsp = '\n'
end_tag_hsp = '\n'
in_seqgroups = False
start_tag_seqgroups = '\n'
end_tag_seqgroups = '\n'
colorarr_tag = 'colorarr='
color_tag = 'color='
for i, original_line in enumerate(original_lines):
if original_line == start_tag_hsp:
in_hsps = True
continue
if original_line == end_tag_hsp:
in_hsps = False
continue
if original_line == start_tag_seqgroups:
in_seqgroups = True
continue
if original_line == end_tag_seqgroups:
in_seqgroups = False
continue
if original_line.startswith(colorarr_tag):
## remove colorarr_tag from beginning of line
original_line = original_line[len(colorarr_tag):].strip().strip(':')
self.assertTrue(written_lines[i].startswith(colorarr_tag))
written_line = written_lines[i][len(colorarr_tag):].strip().strip(':')
original_colors = original_line.replace('(', ''). replace(')', '').split(':')
written_colors = written_line.replace('(', ''). replace(')', '').split(':')
self.assertEqual(len(original_colors), len(written_colors))
for j, original_color_string in enumerate(original_colors):
original_color = Color.from_string(original_color_string)
written_color = Color.from_string(written_colors[j])
self.assertEqual(original_color.r, written_color.r)
self.assertEqual(original_color.g, written_color.g)
self.assertEqual(original_color.b, written_color.b)
self.assertEqual(original_color.a, written_color.a)
continue
if original_line.startswith(color_tag):
original_color_string = original_line[len(color_tag):].strip()
self.assertTrue(written_lines[i].startswith(color_tag))
written_color_string = written_lines[i][len(color_tag):].strip()
original_color = Color.from_string(original_color_string)
written_color = Color.from_string(written_color_string)
self.assertEqual(original_color.r, written_color.r)
self.assertEqual(original_color.g, written_color.g)
self.assertEqual(original_color.b, written_color.b)
self.assertEqual(original_color.a, written_color.a)
continue
if in_hsps:
original_start_end, original_value \
= original_line.strip().split(':')
written_start_end, written_value \
= written_lines[i].strip().split(':')
self.assertEqual(original_start_end, written_start_end)
self.assertTrue((float(original_value) - float(written_value)) < 1e-6)
elif in_seqgroups and (original_line == 'numbers=\n'):
## a terminal semicolon is added by the ClansWriter
self.assertEqual(original_line.strip() + ';', written_lines[i].strip())
else:
self.assertEqual(original_line, written_lines[i])
def tearDown(self):
self.temp.close()
if __name__ == '__main__':
test.Console()