wwood-bioruby 1.2.11

data/test/unit/bio/test_command.rb

@@ -0,0 +1,349 @@
+#
+# test/unit/bio/test_command.rb - Unit test for Bio::Command
+#
+# Copyright::	Copyright (C) 2005-2008
+#               Mitsuteru Nakao <n@bioruby.org>,
+# 		Naohisa Goto <ng@bioruby.org>,
+#		Toshiaki Katayama <k@bioruby.org>
+# License::	The Ruby License
+#
+#  $Id:$
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 3, 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+
+require 'test/unit'
+require 'bio/command'
+
+module Bio
+  class TestCommand < Test::Unit::TestCase
+    
+    def test_command_constants
+      assert(Bio::Command::UNSAFE_CHARS_UNIX)
+      assert(Bio::Command::QUOTE_CHARS_WINDOWS)
+      assert(Bio::Command::UNESCAPABLE_CHARS)
+    end
+
+    def test_escape_shell_windows
+      str = "bio_ruby.123@456:789"
+      assert_equal("bio_ruby.123@456:789",
+                   Bio::Command.escape_shell_windows(str))
+      str = "bio\'\"r u\"b\\y123@456:789"
+      assert_equal("\"bio'\"\"r u\"\"b\\y123@456:789\"",
+                   Bio::Command.escape_shell_windows(str))
+    end
+
+    def test_escape_shell_unix
+      str = "bio_ruby.123@456:789"
+      assert_equal("bio_ruby.123@456:789",
+                   Bio::Command.escape_shell_unix(str))
+      str = "bio\'\"r u\"b\\y123@456:789"
+      assert_equal("bio\\'\\\"r\\ u\\\"b\\\\y123@456:789",
+                   Bio::Command.escape_shell_unix(str))
+    end
+
+    def test_escape_shell
+      str = "bio_ruby.123@456:789"
+      assert_equal("bio_ruby.123@456:789",
+                   Bio::Command.escape_shell(str))
+      str = "bio\'\"r u\"b\\y123@456:789"
+      case RUBY_PLATFORM
+      when /mswin32|bccwin32/
+        assert_equal("\"bio'\"\"r u\"\"b\\y123@456:789\"",
+                     Bio::Command.escape_shell(str))
+      else
+        assert_equal("bio\\'\\\"r\\ u\\\"b\\\\y123@456:789",
+                     Bio::Command.escape_shell(str))
+      end
+    end
+
+    def test_make_command_line
+      ary = [ "ruby", 
+        "test.rb", "atgcatgc", "bio\'\"r u\"b\\y123@456:789" ]
+      case RUBY_PLATFORM
+      when /mswin32|bccwin32/
+        assert_equal("ruby" + 
+                       " test.rb atgcatgc" + 
+                       " \"bio'\"\"r u\"\"b\\y123@456:789\"",
+                     Bio::Command.make_command_line(ary))
+      else
+        assert_equal("ruby" + 
+                       " test.rb atgcatgc" + 
+                       " bio\\'\\\"r\\ u\\\"b\\\\y123@456:789",
+                     Bio::Command.make_command_line(ary))
+      end
+    end
+
+    def test_make_command_line_windows
+      ary = [ "C:\\Program Files\\Ruby\\bin\\ruby.exe", 
+        "test.rb", "atgcatgc", "bio\'\"r u\"b\\y123@456:789" ]
+      assert_equal("\"C:\\Program Files\\Ruby\\bin\\ruby.exe\"" + 
+                     " test.rb atgcatgc" + 
+                     " \"bio'\"\"r u\"\"b\\y123@456:789\"",
+                   Bio::Command.make_command_line_windows(ary))
+    end
+
+    def test_make_command_line_unix
+      ary = [ "/usr/local/bin/ruby", 
+        "test.rb", "atgcatgc", "bio\'\"r u\"b\\y123@456:789" ]
+      assert_equal("/usr/local/bin/ruby" + 
+                     " test.rb atgcatgc" +
+                     " bio\\'\\\"r\\ u\\\"b\\\\y123@456:789",
+                   Bio::Command.make_command_line_unix(ary))
+    end
+
+    def test_safe_command_line_array
+      ary1 = [ 'test' ]
+      assert_equal([ [ 'test', 'test' ] ],
+                   Bio::Command.safe_command_line_array(ary1))
+      ary1a = [ [ 'test/test1a', 'test' ] ]
+      assert_equal(ary1a,
+                   Bio::Command.safe_command_line_array(ary1a))
+    end
+
+    def test_safe_command_line_array_passthrough
+      ary0 = []
+      assert_equal(ary0,
+                   Bio::Command.safe_command_line_array(ary0))
+      ary2 = [ 'cmd', 'arg0' ]
+      assert_equal(ary2,
+                   Bio::Command.safe_command_line_array(ary2))
+      ary2a = [ [ 'cmd', 'display name' ], 'arg0' ]
+      assert_equal(ary2a,
+                   Bio::Command.safe_command_line_array(ary2a))
+      ary3 = [ 'cmd', 'arg0', 'arg1' ]
+      assert_equal(ary3,
+                   Bio::Command.safe_command_line_array(ary3))
+    end
+
+    def test_make_cgi_params_by_hash_in_symbol
+      ary = [
+             "type1=bp",
+             "type2=bp",
+             "downstream=",
+             "upstream=",
+             "format=fasta",
+             "options=similarity",
+             "options=gene",
+             "action=export",
+             "_format=Text",
+             "output=txt",
+             "submit=Continue+%3E%3E",
+             "ab%3Dcd%26ef%3Dgh%23ij=pq%3D12%26rs%3D34%23tu",
+            ]
+      hash = {
+        :type1 => 'bp',
+        :type2 => 'bp',
+        :downstream => '',
+        :upstream => '',
+        :format => 'fasta',
+        :options => ['similarity', 'gene'],
+        :action => 'export',
+        :_format => 'Text',
+        :output => 'txt',
+        :submit => 'Continue >>',
+        :"ab=cd&ef=gh#ij" => 'pq=12&rs=34#tu',
+      }
+      result = Bio::Command.make_cgi_params(hash)
+      ary.each do |str|
+        assert_match(Regexp.new(Regexp.escape(str)), result)
+      end
+
+      # round-trip test
+      result_hash = {}
+      CGI.parse(result).each do |k, v|
+        v = case v.size
+            when 0
+              ''
+            when 1
+              v[0]
+            else
+              v
+            end
+        result_hash[k.intern] = v
+      end
+      assert_equal(hash, result_hash)
+    end
+
+    def test_make_cgi_params_by_hash_in_string
+      ary = [
+             "type1=bp",
+             "type2=bp",
+             "downstream=",
+             "upstream=",
+             "format=fasta",
+             "options=similarity",
+             "options=gene",
+             "action=export",
+             "_format=Text",
+             "output=txt",
+             "submit=Continue+%3E%3E",
+             "ab%3Dcd%26ef%3Dgh%23ij=pq%3D12%26rs%3D34%23tu",
+            ]
+      hash = {
+        "type1" => 'bp',
+        "type2" => 'bp',
+        "downstream" => '',
+        "upstream" => '',
+        "format" => 'fasta',
+        "options" => ['similarity', 'gene'],
+        "action" => 'export',
+        "_format" => 'Text',
+        "output" => 'txt',
+        "submit" => 'Continue >>',
+        'ab=cd&ef=gh#ij' => 'pq=12&rs=34#tu',
+      }
+      result = Bio::Command.make_cgi_params(hash)
+      ary.each do |str|
+        assert_match(Regexp.new(Regexp.escape(str)), result)
+      end
+
+      # round-trip test
+      result_hash = {}
+      CGI.parse(result).each do |k, v|
+        v = case v.size
+            when 0
+              ''
+            when 1
+              v[0]
+            else
+              v
+            end
+        result_hash[k] = v
+      end
+      assert_equal(hash, result_hash)
+    end
+
+    def test_make_cgi_params_by_array_of_array
+      ary = [
+             "type1=bp",
+             "type2=bp",
+             "downstream=",
+             "upstream=",
+             "format=fasta",
+             "options=similarity",
+             "options=gene",
+             "action=export",
+             "_format=Text",
+             "output=txt",
+             "submit=Continue+%3E%3E",
+             "ab%3Dcd%26ef%3Dgh%23ij=pq%3D12%26rs%3D34%23tu",
+            ]
+      array_of_array = [
+        ["type1", 'bp'],
+        ["type2", 'bp'], 
+        ["downstream", ''],
+        ["upstream", ''],
+        ["format", 'fasta'],
+        ["options", ['similarity', 'gene']],
+        ["action", 'export'],
+        ["_format", 'Text'],
+        ["output", 'txt'],
+        ["submit", 'Continue >>'],
+        [ 'ab=cd&ef=gh#ij', 'pq=12&rs=34#tu' ],
+      ]
+      result = Bio::Command.make_cgi_params(array_of_array)
+      # When array of array, order is guaranteed.
+      assert_equal(ary.join('&'), result)
+
+      # round-trip test
+      result_array = []
+      CGI.parse(result).each do |k, v|
+        v = case v.size
+            when 0
+              ''
+            when 1
+              v[0]
+            else
+              v
+            end
+        result_array.push([ k, v ])
+      end
+      assert_equal(array_of_array.sort, result_array.sort)
+    end
+
+    def test_make_cgi_params_by_array_of_hash
+      ary = [
+             "type1=bp",
+             "type2=bp",
+             "downstream=",
+             "upstream=",
+             "format=fasta",
+             "options=similarity",
+             "options=gene",
+             "action=export",
+             "_format=Text",
+             "output=txt",
+             "submit=Continue+%3E%3E",
+             "ab%3Dcd%26ef%3Dgh%23ij=pq%3D12%26rs%3D34%23tu",
+            ]
+      array_of_hash = [
+                       {"type1" => 'bp'},
+                       {"type2" => 'bp'},
+                       {"downstream" => ''},
+                       {"upstream" => ''},
+                       {"format" => 'fasta'},
+                       {"options" => ['similarity', 'gene']},
+                       {"action" => 'export'},
+                       {"_format" => 'Text'},
+                       {"output" => 'txt'},
+                       {"submit" => 'Continue >>'},
+                       {'ab=cd&ef=gh#ij' => 'pq=12&rs=34#tu'},
+                      ]
+      result = Bio::Command.make_cgi_params(array_of_hash)
+      # When array of hash, order is guaranteed.
+      assert_equal(ary.join('&'), result)
+
+      # round-trip test
+      result_array = []
+      CGI.parse(result).each do |k, v|
+        v = case v.size
+            when 0
+              ''
+            when 1
+              v[0]
+            else
+              v
+            end
+        result_array.push({ k => v })
+      end
+      assert_equal(array_of_hash.sort { |x,y| x.keys[0] <=> y.keys[0] },
+                   result_array.sort { |x,y| x.keys[0] <=> y.keys[0] })
+    end
+
+    def test_make_cgi_params_by_array_of_string
+      str = "type1=bp&type2=bp&downstream=&upstream=&format=fasta&options=similarity&options=gene&action=export&_format=Text&output=txt&submit=Continue+%3E%3E&ab=cd%26ef%3Dgh%23ij%3Dpq%3D12%26rs%3D34%23tu"
+      array_of_string = [
+                         "type1=bp",
+                         "type2=bp",
+                         "downstream=",
+                         "upstream=",
+                         "format=fasta",
+                         "options=similarity",
+                         "options=gene",
+                         "action=export",
+                         "_format=Text",
+                         "output=txt",
+                         "submit=Continue >>",
+                         # In the following case, 'ab' is regarded as
+                         # the form key, and rest of the string is
+                         # regarded as the value.
+                         'ab=cd&ef=gh#ij=pq=12&rs=34#tu',
+                        ]
+      result = Bio::Command.make_cgi_params(array_of_string)
+      assert_equal(str, result)
+    end
+
+    def test_make_cgi_params_by_string
+      string = "type1=bp&type2=bp&downstream=&upstream=&format=fasta&options=similarity&options=gene&action=export&_format=Text&output=txt&submit=Continue%20%3E%3E"
+      # In this case, only URI escaping is performed.
+      query = " type1=bp&type2=bp&downstream=&upstream=&format=fasta&options=similarity&options=gene&action=export&_format=Text&output=txt&submit=Continue >> "
+      result = Bio::Command.make_cgi_params(query)
+      assert_equal(string, result)
+    end
+
+  end
+end

data/test/unit/bio/test_db.rb

@@ -0,0 +1,96 @@
+#
+# test/unit/bio/test_db.rb - Unit test for Bio::DB
+#
+# Copyright::  Copyright (C) 2005 Mitsuteru Nakao <n@bioruby.org>
+# License::    The Ruby License
+#
+#  $Id: test_db.rb,v 1.4 2007/04/05 23:35:42 trevor Exp $
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 3, 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+require 'test/unit'
+require 'bio/db'
+
+module Bio
+  class TestDB < Test::Unit::TestCase
+    def setup
+      
+     @obj = Bio::DB.new
+      @obj.instance_eval { @orig = {"TAG" => "TAG value1\n    value2"} }
+    end
+
+    def test_open
+      assert(Bio::DB.respond_to?(:open))
+    end
+ 
+    def test_entry_id
+      assert_raises(NotImplementedError) { @obj.entry_id }
+    end
+
+    def test_tags
+      assert_equal(["TAG"], @obj.tags)
+    end
+    
+    def test_exists
+      assert_equal(true, @obj.exists?("TAG"))
+    end
+
+    def test_get
+      assert_equal("TAG value1\n    value2", @obj.get("TAG"))
+    end
+
+    def test_fetch
+      assert(@obj.fetch("TAG"))
+      assert(@obj.fetch("TAG", 1))
+    end
+  end
+
+
+  class TestNCBIDB < Test::Unit::TestCase
+    def setup
+      entry =<<END
+LOCUS     locus
+END
+      @obj = Bio::NCBIDB.new(entry, 10)
+    end
+
+    def test_fetch
+      assert_equal('locus', @obj.fetch("LOCUS"))
+    end
+
+    def test_p_toptag2array
+    end
+
+    def test_p_subtag2array
+    end
+
+    def test_p_entry2hash
+    end
+  end
+
+#  class TestKEGGDB < Test::Unit::TestCase
+#  end
+  
+  class TestEMBLDB < Test::Unit::TestCase
+    def setup
+      @entry =<<END
+ID id
+XX
+CC cc1
+CC cc2
+END
+      @obj = Bio::EMBLDB.new(@entry, 2)
+    end
+
+    def test_fetch
+      assert_equal('id', @obj.fetch("ID"))
+      assert_equal('cc1 cc2', @obj.fetch("CC"))
+    end
+
+    def test_p_entry2hash
+    end
+  end
+end

data/test/unit/bio/test_feature.rb

@@ -0,0 +1,144 @@
+#
+# test/unit/bio/test_feature.rb - Unit test for Features/Feature classes
+#
+# Copyright::  Copyright (C) 2005 
+#              Mitsuteru Nakao <n@bioruby.org>
+# License::    The Ruby License
+#
+#  $Id: test_feature.rb,v 1.5.2.1 2008/05/08 05:38:01 ngoto Exp $
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 3 , 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+require 'test/unit'
+require 'bio/feature'
+require 'bio/compat/features'
+
+
+module Bio
+
+  class TestQualifier < Test::Unit::TestCase
+    def setup
+      qualifier = 'gene'
+      value = 'CDS'
+      @obj = Bio::Feature::Qualifier.new(qualifier, value)
+    end
+
+    def test_qualifier
+      assert_equal('gene', @obj.qualifier)
+    end
+
+    def test_value
+      assert_equal('CDS', @obj.value)
+    end
+  end
+
+
+  class TestFeature < Test::Unit::TestCase
+    def setup
+      @qualifier = Bio::Feature::Qualifier.new('organism', 'Arabidopsis thaliana')
+      feature = "source"
+      position = '1..615'
+      qualifiers = [@qualifier]
+      @obj = Bio::Feature.new(feature, position, qualifiers)
+    end
+
+    def test_new
+      assert(Bio::Feature.new)
+    end
+
+    def test_feature
+      assert_equal("source", @obj.feature)
+    end
+
+    def test_position
+      assert_equal('1..615', @obj.position)
+    end
+
+    def test_qualifiers
+      assert_equal([@qualifier], @obj.qualifiers)
+    end
+    
+    def test_locations
+      assert_equal(1, @obj.locations.first.from)
+      assert_equal(615, @obj.locations.first.to)
+    end
+
+    def test_append_nil
+      assert(@obj.append(nil))
+      assert_equal(1, @obj.qualifiers.size)
+    end
+
+    def test_append
+      qualifier = Bio::Feature::Qualifier.new('db_xref', 'taxon:3702')
+      assert(@obj.append(qualifier))
+      assert_equal('db_xref', @obj.qualifiers.last.qualifier)
+    end
+
+    def test_each
+      @obj.each do |qua| 
+        assert_equal('Arabidopsis thaliana', qua.value)
+      end
+    end
+
+    def test_assoc
+      @obj.append(Bio::Feature::Qualifier.new("organism", "Arabidopsis thaliana"))
+      assert_equal({"organism" => "Arabidopsis thaliana"}, @obj.assoc)
+    end
+  end
+
+  class NullStderr
+    def initialize
+      @log = []
+    end
+
+    def write(*arg)
+      #p arg
+      @log.push([ :write, *arg ])
+      nil
+    end
+
+    def method_missing(*arg)
+      #p arg
+      @log.push arg
+      nil
+    end
+  end
+
+  class TestFeatures < Test::Unit::TestCase
+    def setup
+      # To suppress warning messages, $stderr is replaced by dummy object.
+      @stderr_orig = $stderr
+      $stderr = NullStderr.new
+
+      @obj = Bio::Features.new([Bio::Feature.new('gene', '1..615', [])])
+    end
+
+    def teardown
+      # bring back $stderr
+      $stderr = @stderr_orig
+    end
+    
+    def test_features
+      assert_equal(1, @obj.features.size)
+    end
+
+    def test_append
+      assert(@obj.append(Bio::Feature.new('gene', '1..615', [])))
+      assert_equal(2, @obj.features.size)
+    end
+
+    def test_each
+      @obj.each do |feature| 
+        assert_equal('gene', feature.feature)
+      end
+    end
+
+    def test_arg # def [](*arg)
+      assert_equal('gene', @obj[0].feature)
+    end
+  end
+
+end