code_ruby/test/maasha/test_seq.rb

   1 #!/usr/bin/env ruby
   2
   3 require 'maasha/seq'
   4 require 'test/unit'
   5 require 'pp'
   6
   7 class TestSeq < Test::Unit::TestCase
   8   def setup
   9     @entry = Seq.new
  10   end
  11
  12   #  def test_Seq# autoremoves whitespace, newlines, and carriage returns
  13   #    dna = Seq.new
  14   #    dna.seq = "A\tT\r\tC\nG  "
  15   #    assert_equal(dna.seq, "ATCG")
  16   #  end
  17
  18   def test_Seq_is_dna_with_no_sequence_type_returns_false
  19     assert(@entry.is_dna? == false)
  20   end
  21
  22   def test_Seq_is_dna_with_dna_sequence_type_returns_true
  23     @entry.type = 'dna'
  24     assert(@entry.is_dna? == true)
  25   end
  26
  27   def test_Seq_is_rna_with_no_sequence_type_returns_false
  28     assert(@entry.is_rna? == false)
  29   end
  30
  31   def test_Seq_is_rna_with_rna_sequence_type_returns_true
  32     @entry.type = 'rna'
  33     assert(@entry.is_rna? == true)
  34   end
  35
  36   def test_Seq_is_protein_with_no_sequence_type_returns_false
  37     assert(@entry.is_protein? == false)
  38   end
  39
  40   def test_Seq_is_protein_with_protein_sequence_type_returns_true
  41     @entry.type = 'protein'
  42     assert(@entry.is_protein? == true)
  43   end
  44
  45   def test_Seq_length_is_correct
  46     @entry.seq = 'ATCG'
  47     assert_equal(4, @entry.length)
  48   end
  49
  50   def test_Seq_indels_is_correct
  51     @entry.seq = 'ATCG.-~_'
  52     assert_equal(4, @entry.indels)
  53   end
  54
  55   def test_Seq_to_rna_raises_if_no_sequence
  56     @entry.type = 'dna'
  57     assert_raise(SeqError) { @entry.to_rna }
  58   end
  59
  60   def test_Seq_to_rna_raises_on_bad_type
  61     @entry.seq  = 'ATCG'
  62     @entry.type = 'rna'
  63     assert_raise(SeqError) { @entry.to_rna }
  64   end
  65
  66   def test_Seq_to_rna_transcribes_correctly
  67     @entry.seq  = 'ATCGatcg'
  68     @entry.type = 'dna'
  69     assert_equal("AUCGaucg", @entry.to_rna)
  70   end
  71
  72   def test_Seq_to_rna_changes_entry_type_to_rna
  73     @entry.seq  = 'ATCGatcg'
  74     @entry.type = 'dna'
  75     @entry.to_rna
  76     assert_equal("rna", @entry.type)
  77   end
  78
  79   def test_Seq_to_dna_raises_if_no_sequence
  80     @entry.type = 'rna'
  81     assert_raise(SeqError) { @entry.to_dna }
  82   end
  83
  84   def test_Seq_to_dna_raises_on_bad_type
  85     @entry.seq  = 'AUCG'
  86     @entry.type = 'dna'
  87     assert_raise(SeqError) { @entry.to_dna }
  88   end
  89
  90   def test_Seq_to_dna_transcribes_correctly
  91     @entry.seq  = 'AUCGaucg'
  92     @entry.type = 'rna'
  93     assert_equal("ATCGatcg", @entry.to_dna)
  94   end
  95
  96   def test_Seq_to_dna_changes_entry_type_to_dna
  97     @entry.seq  = 'AUCGaucg'
  98     @entry.type = 'rna'
  99     @entry.to_dna
 100     assert_equal("dna", @entry.type)
 101   end
 102
 103   def test_Seq_to_bp_returns_correct_record
 104     @entry.seq_name = 'test'
 105     @entry.seq      = 'ATCG'
 106     assert_equal({:SEQ_NAME=>"test", :SEQ=>"ATCG", :SEQ_LEN=>4}, @entry.to_bp)
 107   end
 108
 109   def test_Seq_to_bp_raises_on_missing_seq_name
 110     @entry.seq = 'ATCG'
 111     assert_raise(SeqError) { @entry.to_bp }
 112   end
 113
 114   def test_Seq_to_bp_raises_on_missing_sequence
 115     @entry.seq_name = 'test'
 116     assert_raise(SeqError) { @entry.to_bp }
 117   end
 118
 119   def test_Seq_to_fasta_returns_correct_entry
 120     @entry.seq_name = 'test'
 121     @entry.seq      = 'ATCG'
 122     assert_equal(">test\nATCG\n", @entry.to_fasta)
 123   end
 124
 125   def test_Seq_to_fasta_wraps_correctly
 126     entry = Seq.new("test", "ATCG")
 127     assert_equal(">test\nAT\nCG\n", entry.to_fasta(2))
 128   end
 129
 130   def test_Seq_to_key_with_bad_residue_raises
 131     entry = Seq.new("test", "AUCG")
 132     assert_raise(SeqError) { entry.to_key }
 133   end
 134
 135   def test_Seq_to_key_returns_correctly
 136     entry = Seq.new("test", "ATCG")
 137     assert_equal(54, entry.to_key)
 138   end
 139
 140   def test_Seq_reverse_returns_correctly
 141     @entry.seq = "ATCG"
 142     assert_equal("GCTA", @entry.reverse)
 143   end
 144
 145   def test_Seq_complement_raises_if_no_sequence
 146     @entry.type = 'dna'
 147     assert_raise(SeqError) { @entry.complement }
 148   end
 149
 150   def test_Seq_complement_raises_on_bad_type
 151     @entry.seq  = 'ATCG'
 152     @entry.type = 'protein'
 153     assert_raise(SeqError) { @entry.complement }
 154   end
 155
 156   def test_Seq_complement_for_DNA_is_correct
 157     @entry.seq  = 'ATCGatcg'
 158     @entry.type = 'dna'
 159     assert_equal("TAGCtagc", @entry.complement)
 160   end
 161
 162   def test_Seq_complement_for_RNA_is_correct
 163     @entry.seq  = 'AUCGaucg'
 164     @entry.type = 'rna'
 165     assert_equal("UAGCuagc", @entry.complement)
 166   end
 167
 168   def test_Seq_reverse_complement_for_DNA_is_correct
 169     @entry.seq  = 'ATCGatcg'
 170     @entry.type = 'dna'
 171     assert_equal("cgatCGAT", @entry.reverse_complement)
 172   end
 173
 174   def test_Seq_reverse_complement_for_RNA_is_correct
 175     @entry.seq  = 'AUCGaucg'
 176     @entry.type = 'rna'
 177     assert_equal("cgauCGAU", @entry.reverse_complement)
 178   end
 179
 180   def test_Seq_generate_with_length_lt_1_raises
 181     assert_raise(SeqError) { @entry.generate(-10, "dna") }
 182     assert_raise(SeqError) { @entry.generate(0, "dna") }
 183   end
 184
 185   def test_Seq_generate_with_bad_type_raises
 186     assert_raise(SeqError) { @entry.generate(10, "foo") }
 187   end
 188
 189   def test_Seq_generate_with_ok_type_dont_raise
 190     %w[dna DNA rna RNA protein Protein].each do |type|
 191       assert_nothing_raised { @entry.generate(10, type) }
 192     end
 193   end
 194
 195   def test_Seq_subseq_with_start_lt_0_raises
 196     @entry.seq = "ATCG"
 197     assert_raise(SeqError) { @entry.subseq(-1, 1) }
 198   end
 199
 200   def test_Seq_subseq_with_length_lt_1_raises
 201     @entry.seq = "ATCG"
 202     assert_raise(SeqError) { @entry.subseq(0, 0) }
 203   end
 204
 205   def test_Seq_subseq_with_start_plus_length_gt_seq_raises
 206     @entry.seq = "ATCG"
 207     assert_raise(SeqError) { @entry.subseq(0, 5) }
 208   end
 209
 210   def test_Seq_subseq_returns_correct_sequence
 211     @entry.seq  = "ATCG"
 212     assert_equal("AT", @entry.subseq(0, 2).seq)
 213     assert_equal("CG", @entry.subseq(2, 2).seq)
 214   end
 215
 216   def test_Seq_subseq_without_len_returns_correct_sequence
 217     @entry.seq  = "ATCG"
 218     assert_equal("ATCG", @entry.subseq(0).seq)
 219     assert_equal("CG",   @entry.subseq(2).seq)
 220   end
 221
 222   def test_Seq_subseq_returns_correct_qual
 223     @entry.seq  = "ATCG"
 224     @entry.qual = "abcd"
 225     assert_equal("ab", @entry.subseq(0, 2).qual)
 226     assert_equal("cd", @entry.subseq(2, 2).qual)
 227   end
 228
 229   def test_Seq_subseq_without_len_returns_correct_qual
 230     @entry.seq  = "ATCG"
 231     @entry.qual = "abcd"
 232     assert_equal("abcd", @entry.subseq(0).qual)
 233     assert_equal("cd",   @entry.subseq(2).qual)
 234   end
 235
 236   def test_Seq_subseq_bang_with_start_lt_0_raises
 237     @entry.seq = "ATCG"
 238     assert_raise(SeqError) { @entry.subseq!(-1, 1) }
 239   end
 240
 241   def test_Seq_subseq_bang_with_length_lt_1_raises
 242     @entry.seq = "ATCG"
 243     assert_raise(SeqError) { @entry.subseq!(0, 0) }
 244   end
 245
 246   def test_Seq_subseq_bang_with_start_plus_length_gt_seq_raises
 247     @entry.seq = "ATCG"
 248     assert_raise(SeqError) { @entry.subseq!(0, 5) }
 249   end
 250
 251   def test_Seq_subseq_bang_returns_correct_sequence
 252     @entry.seq  = "ATCG"
 253     @entry.subseq!(0, 2)
 254     assert_equal("AT", @entry.seq)
 255     @entry.seq  = "ATCG"
 256     @entry.subseq!(2, 2)
 257     assert_equal("CG", @entry.seq)
 258   end
 259
 260   def test_Seq_subseq_bang_without_len_returns_correct_sequence
 261     @entry.seq  = "ATCG"
 262     @entry.subseq!(0)
 263     assert_equal("ATCG", @entry.seq)
 264     @entry.seq  = "ATCG"
 265     @entry.subseq!(2)
 266     assert_equal("CG", @entry.seq)
 267   end
 268
 269   def test_Seq_subseq_bang_with_pos_and_len_returns_correct_qual
 270     @entry.seq  = "ATCG"
 271     @entry.qual = "abcd"
 272     @entry.subseq!(0, 2)
 273     assert_equal("ab", @entry.qual)
 274     @entry.seq  = "ATCG"
 275     @entry.qual = "abcd"
 276     @entry.subseq!(2, 2)
 277     assert_equal("cd", @entry.qual)
 278   end
 279
 280   def test_Seq_subseq_bang_with_pos_returns_correct_qual
 281     @entry.seq  = "ATCG"
 282     @entry.qual = "abcd"
 283     @entry.subseq!(0)
 284     assert_equal("abcd", @entry.qual)
 285     @entry.seq  = "ATCG"
 286     @entry.qual = "abcd"
 287     @entry.subseq!(2)
 288     assert_equal("cd", @entry.qual)
 289   end
 290
 291   def test_Seq_subseq_rand_returns_correct_sequence
 292     @entry.seq  = "ATCG"
 293     assert_equal("ATCG", @entry.subseq_rand(4).seq)
 294   end
 295
 296   def test_Seq_composition_returns_correctly
 297     @entry.seq = "AAAATTTCCG"
 298     assert_equal(4, @entry.composition["A"])
 299     assert_equal(3, @entry.composition["T"])
 300     assert_equal(2, @entry.composition["C"])
 301     assert_equal(1, @entry.composition["G"])
 302     assert_equal(0, @entry.composition["X"])
 303   end
 304
 305   def test_Seq_homopol_max_returns_0_with_empty_sequence
 306     @entry.seq = ""
 307     assert_equal(0, @entry.homopol_max)
 308   end
 309
 310   def test_Seq_homopol_max_returns_0_with_nil_sequence
 311     @entry.seq = nil
 312     assert_equal(0, @entry.homopol_max)
 313   end
 314
 315   def test_Seq_homopol_max_returns_0_when_not_found
 316     @entry.seq = "AtTcCcGggGnnNnn"
 317     assert_equal(0, @entry.homopol_max(6))
 318   end
 319
 320   def test_Seq_homopol_max_returns_correctly
 321     @entry.seq = "AtTcCcGggGnnNnn"
 322     assert_equal(5, @entry.homopol_max(3))
 323   end
 324
 325   def test_Seq_hard_mask_returns_correctly
 326     @entry.seq = "--AAAANn"
 327     assert_equal(33.33, @entry.hard_mask)
 328   end
 329
 330   def test_Seq_soft_mask_returns_correctly
 331     @entry.seq = "--AAAa"
 332     assert_equal(25.00, @entry.soft_mask)
 333   end
 334 end
 335
 336
 337 __END__