test/basic_test.py

   1 '''simple, quick unit test cases'''
   2
   3
   4 from __future__ import with_statement
   5
   6 import contextlib
   7
   8 from nose.tools import *
   9
  10 from greylag_grind import *
  11
  12
  13 def same_atoms_test():
  14     assert (set(MONOISOTOPIC_ATOMIC_MASS.keys())
  15             == set(AVERAGE_ATOMIC_MASS.keys()))
  16
  17
  18 class formula_mass_test:
  19     def summation_test(self):
  20         a = formula_mass('C5H9ONS')
  21         b = formula_mass('C5H9   ')
  22         c = formula_mass('    ONS')
  23         assert_almost_equal(a, b+c, places=10)
  24
  25
  26 class read_fasta_files_test:
  27     def simple_test_0(self):
  28         found = list(read_fasta_files(['test/scary.fa']))
  29         wanted = [('ugly test fasta file', '', 'test/scary.fa'),
  30                   ('', 'ABC', 'test/scary.fa'),
  31                   ('1', 'STALEMATING', 'test/scary.fa'),
  32                   (' foo', 'AARDVARKS AARDVARKSAARDVARKS', 'test/scary.fa'),
  33                   ('gi|1234| bleah', 'SISTERLIKE', 'test/scary.fa'),
  34                   ('gi|1234| bleah', 'SISTER*LIKE', 'test/scary.fa'),
  35                   ('control-A here: [\x01]', '& HERE: [\x01]', 'test/scary.fa'),
  36                   ('no final newline after F', 'ARF', 'test/scary.fa')]
  37         assert found == wanted
  38
  39
  40 def read_taxonomy_test():
  41     found = sorted(read_taxonomy('test/test-taxonomy.xml').items())
  42     wanted = [('label', ['labeled.fa']),
  43               ('multiple', ['one.fa', 'two.fa', 'three.fa']),
  44               ('simple.fa', ['simple.fa'])]
  45     assert found == wanted
  46
  47
  48 class read_xml_parameters_test:
  49     def empty_test(self):
  50         assert [] == read_xml_parameters('test/empty-params.xml').items()
  51
  52
  53 class mass_regime_part_test:
  54     @raises(ValueError)
  55     def bad_regime_test(self):
  56         mass_regime_part('NOT_MONO_OR_AVG')
  57
  58     @raises(ValueError)
  59     def bad_syntax_0_test(self):
  60         mass_regime_part('MONO(N15@100%')
  61
  62     @raises(ValueError)
  63     def bad_syntax_1_test(self):
  64         mass_regime_part('MONO(N15)')
  65
  66     @raises(ValueError)
  67     def bad_syntax_2_test(self):
  68         mass_regime_part('MONO(N15@100)')
  69
  70     @raises(ValueError)
  71     def N15_test(self):
  72         mass_regime_part('MONO(C13@99%)')
  73
  74     @raises(ValueError)
  75     def multiple_isotope_test(self):
  76         mass_regime_part('MONO(N15@80%,C13@99%)')
  77
  78     @raises(ValueError)
  79     def bad_prevalence_0_test(self):
  80         mass_regime_part('MONO(N15@100.1%)')
  81
  82     @raises(ValueError)
  83     def bad_prevalence_1_test(self):
  84         mass_regime_part('MONO(N15@-1.1%)')
  85
  86
  87 class mass_regime_list_test:
  88     @raises(ValueError)
  89     def bad_frag_test(self):
  90         mass_regime_list('AVG/AVG')
  91
  92
  93 class parse_mod_term_test:
  94     @raises(ValueError)
  95     def bad_spec_0_test(self):
  96         parse_mod_term('-C2H3ON!!@C')
  97
  98     @raises(ValueError)
  99     def bad_spec_1_test(self):
 100         parse_mod_term('-2C2H3ON!@C')
 101
 102     @raises(ValueError)
 103     def bad_spec_2_test(self):
 104         parse_mod_term('-2Z@C')
 105
 106     @raises(ValueError)
 107     def bad_spec_4_test(self):
 108         parse_mod_term('--C2H3ON@C')
 109
 110     @raises(ValueError)
 111     def bad_spec_5_test(self):
 112         parse_mod_term('-C2H3ON@C foo bar')
 113
 114     @raises(ValueError)
 115     def bad_spec_6_test(self):
 116         parse_mod_term('-C2H3ON@C@G')
 117
 118     @raises(ValueError)
 119     def bad_spec_7_test(self):
 120         parse_mod_term('-C2H3ON@@C')
 121
 122     @raises(ValueError)
 123     def bad_spec_8_test(self):
 124         parse_mod_term('++C2H3ON@C')
 125
 126     @raises(ValueError)
 127     def bad_spec_9_test(self):
 128         parse_mod_term('+C2H3ON@C "foo"')
 129
 130     @raises(ValueError)
 131     def bad_residue_0_test(self):
 132         parse_mod_term('20@Z')
 133
 134     @raises(ValueError)
 135     def bad_residue_1_test(self):
 136         parse_mod_term('20@[C', is_potential=True)
 137
 138     @raises(ValueError)
 139     def bad_residue_2_test(self):
 140         parse_mod_term('20@]C', is_potential=True)
 141
 142     @raises(ValueError)
 143     def bad_delta_0_test(self):
 144         parse_mod_term('0@C', is_potential=True)
 145
 146     @raises(ValueError)
 147     def bad_delta_1_test(self):
 148         parse_mod_term('0.000000001@C', is_potential=True)
 149
 150     @raises(ValueError)
 151     def duplicate_residue_0_test(self):
 152         parse_mod_term('120.0@CC')
 153
 154     @raises(ValueError)
 155     def duplicate_residue_1_test(self):
 156         parse_mod_term('120.0@CC', is_potential=True)
 157
 158     @raises(ValueError)
 159     def duplicate_residue_2_test(self):
 160         parse_mod_term('120.0@STY')
 161
 162
 163 class fixed_mod_list_test:
 164     @raises(ValueError)
 165     def multiple_residue_test(self):
 166         fixed_mod_list('14@ST')
 167
 168
 169 class parse_mod_basic_expression_test:
 170     @raises(ValueError)
 171     def missing_paren_0_test(self):
 172         parse_mod_basic_expression('(80@STY;12@C')
 173
 174     @raises(ValueError)
 175     def missing_paren_1_test(self):
 176         parse_mod_basic_expression('(80@STY')
 177
 178     @raises(ValueError)
 179     def missing_paren_2_test(self):
 180         parse_mod_basic_expression('(((80@STY))')
 181
 182
 183
 184
 185 class potential_mod_list_test:
 186     @raises(ValueError)
 187     def extra_paren_0_test(self):
 188         potential_mod_list('(((80@STY;12@C))))')
 189
 190     @raises(ValueError)
 191     def extra_paren_0_test(self):
 192         potential_mod_list('(((80@STY;12@C)))(')
 193
 194
 195 def XML_PARAMETER_INFO_test():
 196     for k, v in XML_PARAMETER_INFO.iteritems():
 197         kv = "%s: %s" % (k, v)
 198         assert isinstance(k, str)
 199         assert isinstance(v, tuple)
 200         assert 2 <= len(v) <= 3
 201         if v[0] == bool:
 202             assert v[1] == None or v[1] in ('yes', 'no'), kv
 203         elif v[0] in (int, float, str):
 204             assert v[1] == None or isinstance(v[0](v[1]), v[0]), kv
 205         elif isinstance(v[0], tuple):
 206             assert v[1] == None or v[1] in v[0], kv
 207         elif v[0] in (mass_regime_list, fixed_mod_list, potential_mod_list):
 208             assert v[1] == None or isinstance(v[1], str), kv
 209         else:
 210             assert False, kv
 211
 212
 213 class zopen_test:
 214     def read_check(self, filename):
 215         with contextlib.closing(zopen(filename)) as f:
 216             data = f.read()
 217         assert data == 'data\n'
 218
 219     def plain_test(self):
 220         self.read_check('test/data')
 221     def gz_test(self):
 222         self.read_check('test/data.gz')
 223     def bz2_test(self):
 224         self.read_check('test/data.bz2')
 225
 226
 227 class swig_sanity_test:
 228     def vector_test(self):
 229         x = cgreylag.mass_regime_parameters()
 230         x.fixed_residue_mass.resize(100)
 231         assert len(x.fixed_residue_mass) == 100
 232         x.fixed_residue_mass.resize(200, 1.1)
 233         assert len(x.fixed_residue_mass) == 200
 234         for i in range(0, 100):
 235             assert x.fixed_residue_mass[i] == 0.0
 236         for i in range(100, 200):
 237             assert x.fixed_residue_mass[i] == 1.1
 238
 239
 240 def reset_spectrum_ids():
 241     "reset spectrum serial numbers, so that tests are repeatable"
 242     cgreylag.cvar.spectrum_next_id = 0
 243     cgreylag.cvar.spectrum_next_physical_id = 0
 244
 245
 246 class external_type_test:
 247     def peak_repr_test(self):
 248         x = cgreylag.peak()
 249         assert repr(x) == '<peak mz=0.0000 intensity=0.0000>'
 250         x = cgreylag.peak(1234.56, 112233)
 251         assert repr(x) == '<peak mz=1234.5600 intensity=112233.0000>'
 252
 253     def spectrum_repr_test(self):
 254         reset_spectrum_ids()
 255         x = cgreylag.spectrum()
 256         assert repr(x) == "<spectrum #0 (phys #-1) '' 0.0000/+0 [0 peaks, maxI=-1.000000, sumI=-1.000000]>"
 257         x = cgreylag.spectrum(1234.12, 2)
 258         assert repr(x) == "<spectrum #1 (phys #-1) '' 1234.1200/+2 [0 peaks, maxI=-1.000000, sumI=-1.000000]>"
 259
 260     def set_peaks_from_matrix_test(self):
 261         reset_spectrum_ids()
 262         x = cgreylag.spectrum()
 263         x.set_peaks_from_matrix([(1.0,2.0), (3.5,4.5), (5.0,6.0)])
 264         assert repr(x) == "<spectrum #0 (phys #-1) '' 0.0000/+0 [3 peaks, maxI=-1.000000, sumI=-1.000000]>"
 265
 266
 267
 268 class spectrum_test:
 269     def simple_read_test(self):
 270         reset_spectrum_ids()
 271         FILEID = 8
 272         with open('test/simple.ms2') as f:
 273             x = cgreylag.spectrum.read_spectra_from_ms2(f, FILEID)
 274         assert len(x) == 6
 275         wanted = ("<spectrum #0 (phys #0) '0002.0002.2' 2096.1000/+2 [356 peaks, maxI=2475458.000000, sumI=19305560.000000]>",
 276                   "<spectrum #1 (phys #0) '0002.0002.3' 3143.6600/+3 [356 peaks, maxI=2475458.000000, sumI=19305560.000000]>",
 277                   "<spectrum #2 (phys #1) '0003.0003.2' 2307.4200/+2 [160 peaks, maxI=13492.000000, sumI=535952.000000]>",
 278                   "<spectrum #3 (phys #1) '0003.0003.3' 3460.6000/+3 [160 peaks, maxI=13492.000000, sumI=535952.000000]>",
 279                   "<spectrum #4 (phys #2) '0006.0006.2' 2057.9100/+2 [410 peaks, maxI=689515.000000, sumI=4639641.000000]>",
 280                   "<spectrum #5 (phys #2) '0006.0006.3' 3086.2400/+3 [410 peaks, maxI=689515.000000, sumI=4639641.000000]>")
 281         for n, sp in enumerate(x):
 282             assert repr(sp) == wanted[n], "checking %s" % n
 283             assert sp.file_id == FILEID
 284
 285     @raises(RuntimeError)
 286     def ms2_instead_of_ms2_plus_test(self):
 287         reset_spectrum_ids()
 288         with open('test/simple.ms2') as f:
 289             x = cgreylag.spectrum.read_spectra_from_ms2(f, -1)
 290
 291
 292 class read_spectra_test:
 293     F = 'test/junk.ms2'
 294     def setup(self):
 295         self.create_ms2([''], False)    # just checking that we can
 296
 297     def create_ms2(self, contents, final_newline=True):
 298         assert not isinstance(contents, str)
 299         with open(self.F, 'w') as f:
 300             f.write('\n'.join(contents))
 301             if final_newline:
 302                 f.write('\n')
 303
 304     def read_ms2(self, contents, final_newline=True):
 305         reset_spectrum_ids()
 306         self.create_ms2(contents, final_newline)
 307         with open(self.F) as f:
 308             return cgreylag.spectrum.read_spectra_from_ms2(f, 1)
 309
 310     def test_empty(self):
 311         assert len(self.read_ms2([''], False)) == 0
 312
 313     def test_wordy_name(self):
 314         lines = [':blah blah blah', '1234.5 1', '123 456']
 315         wanted = "(<spectrum #0 (phys #0) 'blah blah blah' 1234.5000/+1 [1 peaks, maxI=456.000000, sumI=456.000000]>,)"
 316         assert wanted == repr(self.read_ms2(lines))
 317
 318     @raises(RuntimeError)
 319     def test_no_peaks_at_eof(self):
 320         self.read_ms2([':0002.0002.1', '1234.5 1'])
 321
 322     @raises(RuntimeError)
 323     def test_missing_mass_charge(self):
 324         self.read_ms2([':'])
 325
 326     @raises(RuntimeError)
 327     def test_missing_additional_mass_charge(self):
 328         self.read_ms2([':0002.0002.2', '1234.5 2', ':0002.0002.3'])
 329
 330     @raises(RuntimeError)
 331     def test_extra_following_mass_charge(self):
 332         self.read_ms2([':0002.0002.2', '1234.5 2 3', '123 456 789'])
 333
 334     @raises(RuntimeError)
 335     def test_extra_following_peak(self):
 336         self.read_ms2([':0002.0002.2', '1234.5 2', '123 456 789'])
 337
 338     @raises(RuntimeError)
 339     def test_missing_colon_line(self):
 340         self.read_ms2(['1234.5 2', '123 456 789'])
 341
 342     @raises(RuntimeError)
 343     def test_bad_number_0(self):
 344         self.read_ms2([':0002.0002.2', 'a1234.5 2', '123 456'])
 345
 346     @raises(RuntimeError)
 347     def test_bad_number_1(self):
 348         self.read_ms2([':0002.0002.2', '1234.5 a2', '123 456'])
 349
 350     @raises(RuntimeError)
 351     def test_bad_number_2(self):
 352         self.read_ms2([':0002.0002.2', '1234.5 2', 'a123 456'])
 353
 354     @raises(RuntimeError)
 355     def test_bad_number_3(self):
 356         self.read_ms2([':0002.0002.2', '1234.5 2', '123 a456'])
 357
 358     @raises(RuntimeError)
 359     def test_nonpositive_number_0(self):
 360         self.read_ms2([':0002.0002.2', '-1234.5 2', '123 456'])
 361
 362     @raises(RuntimeError)
 363     def test_nonpositive_number_1(self):
 364         self.read_ms2([':0002.0002.2', '1234.5 -2', '123 456'])
 365
 366     @raises(RuntimeError)
 367     def test_nonpositive_number_2(self):
 368         self.read_ms2([':0002.0002.2', '1234.5 2', '-123 456'])
 369
 370     @raises(RuntimeError)
 371     def test_nonpositive_number_3(self):
 372         self.read_ms2([':0002.0002.2', '1234.5 2', '123 -456'])
 373
 374     @raises(RuntimeError)
 375     def test_zero_number_0(self):
 376         self.read_ms2([':0002.0002.2', '0.0 2', '123 456'])
 377
 378     @raises(RuntimeError)
 379     def test_zero_number_1(self):
 380         self.read_ms2([':0002.0002.2', '1234.5 0', '123 456'])
 381
 382     @raises(RuntimeError)
 383     def test_zero_number_2(self):
 384         self.read_ms2([':0002.0002.2', '1234.5 2', '0.0 456'])
 385
 386     @raises(RuntimeError)
 387     def test_bad_blank_0(self):
 388         self.read_ms2([''])
 389
 390     @raises(RuntimeError)
 391     def test_bad_blank_1(self):
 392         self.read_ms2([':0002.0002.2', '', '1234.5 2', '123 456'])
 393
 394     @raises(RuntimeError)
 395     def test_bad_blank_2(self):
 396         self.read_ms2([':0002.0002.2', '1234.5 2', '', '123 456'])
 397
 398     def test_read_masses_0(self):
 399         ms = cgreylag.spectrum.read_ms2_spectrum_masses(())
 400         assert ms == ()
 401
 402     def test_read_masses_1(self):
 403         self.create_ms2([':', '10234.5 2', '123 456',
 404                          ':', '30234.5 2', '123 456',
 405                          ':', '20234.5 2', '123 456',])
 406         with open(self.F) as f:
 407             fn = f.fileno()
 408             ms = cgreylag.spectrum.read_ms2_spectrum_masses((fn,))
 409         assert ms == (10234.5, 20234.5, 30234.5)
 410
 411     def test_read_masses_2(self):
 412         self.create_ms2([':', '102.5 2', '123 456',
 413                          ':', '302.5 2', '123 456',
 414                          ':', '202.5 2', '123 456',])
 415         with open(self.F) as f1:
 416             fn1 = f1.fileno()
 417             with open(self.F) as f2:
 418                 fn2 = f2.fileno()
 419                 ms = cgreylag.spectrum.read_ms2_spectrum_masses((fn1, fn2))
 420                 assert ms == (102.5, 102.5, 202.5, 202.5, 302.5, 302.5)
 421
 422     def teardown(self):
 423         os.remove(self.F)
 424
 425
 426 # FIX: more cgreylag testing to do here