bio-nexml 0.0.1

data/test/unit/bio/db/nexml/tc_mapper.rb

@@ -0,0 +1,78 @@
+module Bio
+  module NeXML
+    class TestMapper < Test::Unit::TestCase
+
+      class Target
+        include Bio::NeXML::Mapper
+
+        attr_accessor   :id
+        belongs_to      :source
+      end
+
+      class Source
+        include Bio::NeXML::Mapper
+
+        attr_accessor  :id
+        has_n          :targets
+      end
+
+      def setup
+        @s  = Source.new
+        @t1 = Target.new
+        @t1.id = 't1'
+        @t2 = Target.new
+        @t2.id = 't2'
+        @s.add_target( @t1 )
+      end
+
+      def test_has_target
+        t2 = Target.new
+        assert @s.has_target?( @t1 )
+        assert !@s.has_target?( t2 )
+      end
+
+      def test_get_target_by_id
+        assert_equal( @t1, @s.get_target_by_id( 't1' ) )
+        assert_nil( @s.get_target_by_id( 't2' ) )
+      end
+
+      def test_add_target
+        t2 = Target.new
+        t2.id = 't2'
+        @s.add_target( t2 )
+
+        assert @s.has_target?( t2 )
+        assert_equal( @s, t2.source )
+      end
+
+      def test_target
+        assert_equal( [ @t1 ], @s.targets )
+      end
+
+      def test_target=
+        t2 = Target.new
+        @s.targets = [ t2 ]
+        assert_equal( [ t2 ], @s.targets )
+        assert_equal( @s, t2.source )
+      end
+
+      def test_delete_target
+        assert_equal( @t1, @s.delete_target( @t1 ) )
+        assert_nil( @t1.source )
+      end
+
+      def test_source
+        assert_equal( @s, @t1.source )
+        assert( @s.has_target?( @t1 ) )
+      end
+
+      def test_source=
+        t2 = Target.new
+        t2.id = 't2'
+        t2.source = @s
+        assert_equal( @s, t2.source )
+        assert( @s.has_target?( t2 ) )
+      end
+    end #end TestOtu
+  end #end NeXML
+end #end Bio

data/test/unit/bio/db/nexml/tc_matrix.rb

@@ -0,0 +1,551 @@
+module Bio
+  module NeXML
+    class TestState < Test::Unit::TestCase
+      def setup
+        @state = Bio::NeXML::State.new( 'stateA', 'A' )
+      end
+
+      def test_new1
+        # if one argument given use it as id
+        s = Bio::NeXML::State.new( 'stateA' )
+        assert_equal 'stateA', s.id
+      end
+
+      def test_new2
+        # if two argument given use them as id and sybmol respectively
+        s = Bio::NeXML::State.new( 'stateA', 'A' )
+        assert_equal 'stateA', s.id
+        assert_equal 'A', s.symbol
+      end
+
+      def test_new3
+        # options hash as third argument
+        # preferred
+        s = Bio::NeXML::State.new( 'stateA', 'A', :label => 'A label' )
+        assert_equal 'stateA', s.id
+        assert_equal 'A', s.symbol
+        assert_equal 'A label', s.label
+      end
+
+      def test_new4
+        # options hash as second argument
+        s = Bio::NeXML::State.new( 'stateA', :symbol => 'A', :label => 'A label' )
+        assert_equal 'stateA', s.id
+        assert_equal 'A', s.symbol
+        assert_equal 'A label', s.label
+      end
+
+      def test_id
+        @state.id = 'state1'
+        assert_equal 'state1', @state.id
+      end
+
+      def test_symbol
+        @state.symbol = 1
+        assert_equal 1, @state.symbol
+      end
+
+      def test_label
+        @state.label = 'State'
+        assert_equal 'State', @state.label
+      end
+
+      def test_ambiguous
+        assert !@state.ambiguous?
+      end
+
+      def test_ambiguity
+        assert_nil @state.ambiguity
+      end
+
+      def test_to_str
+        assert_equal 'A', @state.to_str
+      end
+    end
+
+    class TestAmbiguousState < TestState
+      def setup
+        @members = [
+          %w|s1 A|,
+          %w|s2 B|,
+          %w|s3 C|,
+          %w|s4 D|,
+          %w|s5 E|
+        ].map { | pair | Bio::NeXML::State.new( *pair ) }
+
+        @state = Bio::NeXML::State.uncertain( 'state1', '?' )
+        @state.members = @members
+      end
+
+      def test_new5
+        s = Bio::NeXML::State.new( 'stateA', 'A', :ambiguity => :polymorphic )
+        assert s.ambiguous?
+        assert_equal :polymorphic, s.ambiguity
+      end
+
+      def test_new6
+        s = Bio::NeXML::State.new( 'stateA', 'A', :ambiguity => :uncertain, :members => @members )
+        assert_equal @members, s.members
+      end
+
+      def test_uncertain
+        s = Bio::NeXML::State.uncertain( 'stateA', 'A', :members => @members )
+        assert s.ambiguous?
+        assert_equal :uncertain, s.ambiguity
+        assert_equal @members, s.members
+      end
+
+      def test_polymorphic
+        s = Bio::NeXML::State.polymorphic( 'stateA', 'A', :members => @members )
+        assert s.ambiguous?
+        assert_equal :polymorphic, s.ambiguity
+        assert_equal @members, s.members
+      end
+
+      def test_ambiguous
+        assert @state.ambiguous?
+      end
+
+      def test_ambiguity
+        assert_equal :uncertain, @state.ambiguity
+      end
+
+      def test_add_member
+        s = Bio::NeXML::State.new( 's6', 'F' )
+        @state.add_member( s )
+        assert @state.has_member?( s )
+        assert_equal @state, s.state_set
+      end
+
+      def test_delete_member
+        s = @members[ 0 ]
+        assert_equal( s, @state.delete_member( s ) )
+        assert_nil s.state_set
+      end
+
+      def test_members
+        s = @members[ 0 ]
+        @state.members = [ s ]
+        assert_equal [ s ], @state.members
+        assert_equal @state, s.state_set
+      end
+
+      def test_include
+        assert @state.include?( @members[ 0 ] )
+      end
+      
+      def test_count
+        assert_equal @members.length, @state.count
+      end
+
+      def test_each
+      end
+
+      def test_each_with_symbol
+      end
+
+      def test_to_str
+        assert_equal '?', @state.to_str
+      end
+    end #end class TestAmbiguousState
+
+    class TestChar < Test::Unit::TestCase
+      def setup
+        @states = Bio::NeXML::States.new( 'states' )
+        @char = Bio::NeXML::Char.new( 'char1' )
+      end
+
+      def test_new1
+        # if one argument given use it as id
+        c = Bio::NeXML::Char.new( 'char1' )
+        assert_equal 'char1', c.id
+      end
+
+      def test_new2
+        # if two arguments given use the second as states
+        c = Bio::NeXML::Char.new( 'char1', @states )
+        assert_equal 'char1', c.id
+        assert_equal @states, c.states
+      end
+
+      def test_new3
+        # 3rd argument as optional hash
+        c = Bio::NeXML::Char.new( 'char1', @states, :label => 'A label' )
+        assert_equal 'char1', c.id
+        assert_equal @states, c.states
+        assert_equal 'A label', c.label
+      end
+
+      def test_new4
+        # 2nd argument as optional hash
+        c = Bio::NeXML::Char.new( 'char1', :states => @states, :label => 'A label' )
+        assert_equal 'char1', c.id
+        assert_equal @states, c.states
+        assert_equal 'A label', c.label
+      end
+
+      def test_id
+        @char.id = 'char2'
+        assert_equal 'char2', @char.id
+      end
+
+      def test_label
+        @char.label = 'A label'
+        assert_equal 'A label', @char.label
+      end
+
+      def test_states
+        @char.states = @states
+        assert_equal @states, @char.states
+        assert @states.has_char?( @char )
+      end
+
+      def test_cells
+        cell = Bio::NeXML::Cell.new( @char )
+        assert_equal [ cell ], @char.cells
+      end
+    end
+
+    class TestStates < Test::Unit::TestCase
+      def setup
+        @ss = [
+          %w|s1 A|,
+          %w|s2 B|,
+          %w|s3 C|,
+          %w|s4 D|,
+          %w|s5 E|
+        ].map { | pair | Bio::NeXML::State.new( *pair ) }
+        @states = Bio::NeXML::States.new( 'states', :states => @ss )
+      end
+
+      def test_new1
+        # one argument => id
+        states = Bio::NeXML::States.new( 'states' )
+        assert_equal 'states', states.id
+      end
+
+      def test_new2
+        # second argument => optional hash
+        states = Bio::NeXML::States.new( 'states', :label => 'state container' )
+        assert_equal 'states', states.id
+        assert_equal 'state container', states.label
+      end
+
+      def test_id
+        @states.id = 'states1'
+        assert_equal 'states1', @states.id
+      end
+
+      def test_label
+        @states.label = 'a label'
+        assert_equal 'a label', @states.label
+      end
+
+      def test_add_state
+        s = Bio::NeXML::State.new( 's6', 'F' )
+        @states.add_state( s )
+        assert @states.include?( s )
+        assert_equal @states, s.states
+      end
+
+      def test_delete_state
+        s = @ss[ 0 ]
+        assert_equal s, @states.delete_state( s )
+        assert_nil s.states
+      end
+
+      def test_states
+        s = @ss[ 0 ]
+        @states.states = [ s ]
+        assert_equal [ s ], @states.states
+        assert_equal @states, s.states
+      end
+
+      def test_get_state_by_id
+        s = @ss[ 0 ]
+        assert_equal s, @states.get_state_by_id( s.id )
+      end
+
+      def test_has_state
+        assert @states.has_state?( @ss[ 0 ] )
+      end
+
+      def test_chars
+        char = Bio::NeXML::Char.new( 'char', @states )
+        assert_equal @states, char.states
+        assert_equal [ char ], @states.chars
+      end
+    end
+
+    class TestCell_new < Test::Unit::TestCase
+      # test Bio::NeXML::Cell.new as a cell can be initialized in mulitple ways
+      # depending on type( bound/ unbound ) and need.
+
+      def test_new1
+        # unbound cell, no options
+        cell = Bio::NeXML::Cell.new( 'A' )
+        assert_equal 'A', cell.value
+      end
+
+      def test_new2
+        # unbound cell, with options
+        cell = Bio::NeXML::Cell.new( 'A', :label => 'label' )
+        assert_equal 'A', cell.value
+        assert_equal 'label', cell.label
+      end
+
+      def test_new3
+        # bound cell, no options
+        ch = Bio::NeXML::Char.new( 'ch' )
+        s = Bio::NeXML::State.new( 'ss' )
+        cell = Bio::NeXML::Cell.new( ch, s )
+        assert_equal ch, cell.char
+        assert_equal s, cell.state
+      end
+
+      def test_new4
+        # bound cell, with options
+        ch = Bio::NeXML::Char.new( 'ch' )
+        s = Bio::NeXML::State.new( 'ss' )
+        cell = Bio::NeXML::Cell.new( ch, s, :label => 'label' )
+        assert_equal ch, cell.char
+        assert_equal s, cell.state
+        assert_equal 'label', cell.label
+      end
+
+      def test_new5
+        # all keyword args
+        ch = Bio::NeXML::Char.new( 'ch' )
+        s = Bio::NeXML::State.new( 'ss' )
+        cell = Bio::NeXML::Cell.new( :char => ch, :state => s, :label => 'label' )
+        assert_equal ch, cell.char
+        assert_equal s, cell.state
+        assert_equal 'label', cell.label
+      end
+    end
+
+    class TestUnboundCell < Test::Unit::TestCase
+      def setup
+        @cell = Bio::NeXML::Cell.new( 'A', :label => 'label' )
+      end
+
+      def test_state
+        assert_nil @cell.state
+      end
+
+      def test_char
+        assert_nil @cell.char
+      end
+
+      def test_bound
+        assert !@cell.bound?
+      end
+
+      def test_value
+        @cell.value = 'B'
+        assert_equal 'B', @cell.value
+      end
+    end
+
+    class TestBoundCell < Test::Unit::TestCase
+      def setup
+        @stateA = Bio::NeXML::State.new( 'stateA', 'A' )
+        @char = Bio::NeXML::Char.new( 'char' )
+        @cell = Bio::NeXML::Cell.new( :char => @char, :state => @stateA )
+      end
+
+      def test_state
+        s = Bio::NeXML::State.new( 'stateB', 'B' )
+        @cell.state = s
+        assert_equal s, @cell.state
+      end
+
+      def test_char
+        c = Bio::NeXML::Char.new( 'ch' )
+        @cell.char = c
+        assert_equal c, @cell.char
+      end
+
+      def test_value
+        assert_equal @stateA.symbol, @cell.value
+        @cell.value = 'B'
+        assert_not_equal 'B', @cell.value # since it is a bound cell
+        @stateA.symbol = 'B'
+        assert_equal 'B', @cell.value # a bound cell reflects the value of its state
+      end
+    end
+
+    class TestRow < Test::Unit::TestCase
+      def setup
+        @row = Bio::NeXML::Row.new( 'seq' )
+      end
+
+      def test_id
+        @row.id = 'seq1'
+        assert_equal 'seq1', @row.id
+      end
+
+      def test_label
+        @row.label = 'a sequence'
+        assert_equal 'a sequence', @row.label
+      end
+
+      def test_otu
+        otu = Bio::NeXML::Otu.new( 'otu' )
+        @row.otu = otu
+        assert_equal otu, @row.otu
+        assert_equal [ @row ], otu.rows
+      end
+    end
+
+    class TestMatrix < Test::Unit::TestCase
+      def setup
+        @ss = [
+          %w|s1 A|,
+          %w|s2 B|,
+          %w|s3 C|,
+          %w|s4 D|,
+          %w|s5 E|
+        ].map { | pair | Bio::NeXML::State.new( *pair ) }
+        @states = Bio::NeXML::States.new( 'states', :states => @ss )
+
+        @char1 = Bio::NeXML::Char.new( 'char1', :states => @states )
+        @char2 = Bio::NeXML::Char.new( 'char2', :states => @states )
+
+        @sequence = Bio::NeXML::Sequence.new( :value => 'ABCDE' )
+        @row = Bio::NeXML::SeqRow.new( 'row1' )
+        @matrix = Bio::NeXML::Protein.new( 'matrix1' )
+        @format = Bio::NeXML::Format.new
+        @format.add_states( @states )
+        @format.chars = [ @char1, @char2 ]
+        @row.add_sequence( @sequence )
+      end
+
+      def test_id
+        @matrix.id = 'id'
+        assert_equal 'id', @matrix.id
+      end
+
+      def test_label
+        @matrix.label = 'label'
+        assert_equal 'label', @matrix.label
+      end
+
+      def test_nexml; end
+
+      def test_otus
+        otus = Bio::NeXML::Otus.new( 'otus' )
+        @matrix.otus = otus
+        assert_equal otus, @matrix.otus
+        assert_equal [ @matrix ], otus.characters
+      end
+
+      def test_add_states
+        ss = Bio::NeXML::States.new( 'ss' )
+        @format.add_states( ss )
+        assert @format.has_states?( ss )
+        assert_equal @format, ss.format
+      end
+
+      def test_add_char
+        ch = Bio::NeXML::Char.new( 'ch' )
+        @format.add_char( ch )
+        assert @format.has_char?( ch )
+        assert_equal @format, ch.format
+      end
+
+      def test_add_sequence
+        seq = Bio::NeXML::Sequence.new
+        @row.add_sequence( seq )
+        assert @row.has_sequence?( seq )
+        assert_equal @row, seq.seqrow
+      end
+
+      def test_delete_states
+        assert_equal @states, @format.delete_states( @states )
+        assert !@format.has_states?( @states )
+        assert_nil @states.format
+      end
+
+      def test_delete_char
+        assert_equal @char1, @format.delete_char( @char1 )
+        assert !@format.has_char?( @char1 )
+        assert_nil @char1.format
+      end
+
+      def test_delete_sequence
+        assert_equal @sequence, @row.delete_sequence( @sequence )
+        assert !@row.has_sequence?( @sequence )
+        assert_nil @sequence.row
+      end
+
+      def test_states
+        assert_equal [ @states ], @format.states
+        ss = Bio::NeXML::States.new( 'ss' )
+        @format.states = [ ss ]
+        assert_equal [ ss ], @format.states
+      end
+
+      def test_chars
+        assert_equal [ @char1, @char2 ], @format.chars
+        ch = Bio::NeXML::Char.new( 'ch' )
+        @format.chars = [ ch ]
+        assert_equal [ ch ], @format.chars
+      end
+
+      def test_sequences
+        assert_equal [ @sequence ], @row.sequences
+        seq = Bio::NeXML::Sequence.new
+        @row.sequences = [ seq ]
+        assert_equal [ seq ], @row.sequences
+      end
+
+      def test_get_states_by_id
+        assert_equal @states, @format.get_states_by_id( 'states' )
+      end
+
+      def test_get_char_by_id
+        assert_equal @char1, @format.get_char_by_id( 'char1' )
+      end
+
+      def test_each_states
+        c = 0
+        @format.each_states do |s|
+          assert @format.has_states?( s )
+          c += 1
+        end
+        assert_equal 1, c
+      end
+      
+      def test_each_char
+        c = 0
+        @format.each_char do |ch|
+          assert @format.has_char?( ch )
+          c += 1
+        end
+        assert_equal 2, c
+      end
+
+      def test_each_sequence
+        c = 0
+        @row.each_sequence do |s|
+          assert @row.has_sequence?( s )
+          c += 1
+        end
+        assert_equal 1, c
+      end
+
+      def test_number_of_states
+        assert_equal 1, @format.number_of_states
+      end
+
+      def test_number_of_chars
+        assert_equal 2, @format.number_of_chars
+      end
+
+      def test_number_of_sequences
+        assert_equal 1, @row.number_of_sequences
+      end
+    end
+  end #end module NeXML
+end #end module Bio