bio-nexml 0.0.1

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

@@ -0,0 +1,21 @@
+module Bio
+  module NeXML
+    class TestParser < Test::Unit::TestCase
+
+      def setup
+        @doc = Parser.new( TEST_FILE, true )
+      end
+
+      def teardown
+        @doc.close
+      end
+
+      def test_parse
+        nexml = @doc.parse
+        assert_instance_of Bio::NeXML::Nexml, nexml, "Should return an object of Bio::NeXML::Nexml"
+      end
+
+    end #end class TestParser
+  end #end module NeXML
+
+end #end module Bio

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

@@ -0,0 +1,118 @@
+module Bio
+  module NeXML
+    class TestOtu < Test::Unit::TestCase
+      def setup
+        @otu = Bio::NeXML::Otu.new( 'taxon1', :label => 'A label for taxon1' )
+      end
+
+      def test_id
+        assert_equal( 'taxon1', @otu.id )
+      end
+
+      def test_label
+        assert_equal( 'A label for taxon1', @otu.label )
+      end
+
+      def test_id=
+        @otu.id = 'taxon2'
+        assert_equal( 'taxon2', @otu.id )
+      end
+
+      def test_label=
+        @otu.label = 'New label for taxon1' 
+        assert_equal( 'New label for taxon1', @otu.label )
+      end
+    end
+
+    class TestOtus < Test::Unit::TestCase
+      def setup
+        @otu1 = Bio::NeXML::Otu.new( 'taxon1', :label => 'A label for taxon1' )
+        @otu2 = Bio::NeXML::Otu.new( 'taxon2', :label => 'A label for taxon2' )
+        @otu3 = Bio::NeXML::Otu.new( 'taxon3', :label => 'A label for taxon3' )
+        @otus = Bio::NeXML::Otus.new( 'taxa1', :label => 'A label for taxa1' )
+        @otus << @otu1 << @otu2
+      end
+
+      def test_id
+        assert_equal( 'taxa1', @otus.id )
+      end
+
+      def test_label
+        assert_equal( 'A label for taxa1', @otus.label )
+      end
+
+      def test_id=
+        @otus.id = 'taxa2'
+        assert_equal( 'taxa2', @otus.id )
+      end
+
+      def test_label=
+        @otus.label = 'New label for taxa1' 
+        assert_equal( 'New label for taxa1', @otus.label )
+      end
+
+      def test_hash_notation
+        assert_equal( @otu1, @otus[ 'taxon1' ] )
+      end
+
+      def test_append_operator
+        assert !@otus.include?( @otu3 )
+        rvalue = @otus << @otu3
+
+        # it should append otu to self
+        assert @otus.include?( @otu3 )
+
+        # it should return self, so that appends can be chained
+        assert_instance_of Otus, rvalue
+      end
+
+      def test_delete
+        rvalue = @otus.delete( @otu2 )
+
+        # it should delete @otu2
+        assert !@otus.include?( @otu2 )
+
+        # it should return the deleted object
+        assert_equal @otu2, rvalue
+      end
+
+      def test_otus
+        [ @otu1, @otu2 ].each do |otu|
+          @otus.otus.include?( otu )
+        end
+      end
+
+      def test_otus=
+        assert !@otus.include?( @otu3 )
+        @otus.otus = [ @otu3 ]
+        assert @otus.include?( @otu3 )
+      end
+
+      def test_each
+        otus = [ @otu1, @otu2 ]
+        @otus.each do |otu|
+          assert otus.include?( otu )
+        end
+      end
+
+      def test_each_with_id
+        otus = [ @otu1, @otu2 ]
+        @otus.each_with_id do |id, otu|
+          assert otus.include?( otu )
+          assert otus.include?( @otus[ id ] )
+        end
+      end
+
+      def test_length
+        assert_equal 2, @otus.length
+      end
+
+      def test_include
+        # it should respond for an otu object
+        assert @otus.include?( @otu1 )
+
+        assert !@otus.include?( @otu3 )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,370 @@
+class TestNode < Test::Unit::TestCase
+  def setup
+    @otu = Bio::NeXML::Otu.new( 'o1' )
+    @node = Bio::NeXML::Node.new( 'n1' )
+    @node.otu = @otu
+  end
+
+  def test_id
+    @node.id = 'foo'
+    assert_equal( 'foo', @node.id )
+  end
+
+  def test_label
+    @node.label = 'a node'
+    assert_equal( 'a node', @node.label )
+  end
+
+  def test_root?
+    assert( !@node.root? )
+  end
+
+  def test_root=
+    @node.root = true
+    assert( @node.root )
+  end
+
+  def test_otu
+    otu = Bio::NeXML::Otu.new( 'o2' )
+    @node.otu = otu
+
+    assert_equal( otu, @node.otu )
+    assert_equal( otu.nodes, [ @node ] )
+  end
+
+end
+
+class TestEdge < Test::Unit::TestCase
+  def setup
+    @n1 = Bio::NeXML::Node.new( 'n1' )
+    @n2 = Bio::NeXML::Node.new( 'n2' )
+    @edge = Bio::NeXML::Edge.new( 'e1', :source => @n1, :target => @n2 )
+  end
+
+  def test_id
+    @edge.id = 'e2'
+    assert_equal( 'e2', @edge.id )
+  end
+
+  def test_label
+    @edge.label = 'an edge'
+    assert_equal( 'an edge', @edge.label )
+  end
+
+  def test_source
+    n3 = Bio::NeXML::Node.new( 'n3' )
+    @edge.source = n3
+    assert_equal( n3, @edge.source )
+  end
+
+  def test_target
+    n3 = Bio::NeXML::Node.new( 'n3' )
+    @edge.target = n3
+    assert_equal( n3, @edge.target )
+  end
+
+  def test_length
+    @edge.length = 1
+    assert_equal( 1, @edge.length )
+  end
+end
+
+class TestRootEdge < TestEdge
+  def setup
+    @edge = Bio::NeXML::RootEdge.new( 're1', :target => @n1 )
+  end
+
+  def test_source
+    assert !@re.respond_to?( :source= )
+  end
+end
+
+class TestTree < Test::Unit::TestCase
+
+  def setup
+    @roots = %w|n1 n9|.map { |n| Bio::NeXML::Node.new( n, :root => true ) }
+    @nodes = %w|n2 n3 n4 n5 n6 n7 n8|.map { |n| Bio::NeXML::Node.new( n ) }
+    @nodes = @nodes + @roots
+
+    @edges = %w|e12 e13 e34 e37 e45 e46 e78 e79|.map do |e|
+      source = @nodes.find { |n| n.id == "n#{e[1,1]}" }
+      target = @nodes.find { |n| n.id == "n#{e[2,1]}" }
+      Bio::NeXML::Edge.new( e, :source => source, :target => target )
+    end
+
+    @re = Bio::NeXML::RootEdge.new( 're1', :target => @n1 )
+
+    @tree = Bio::NeXML::Tree.new( 'tree1', :nodes => @nodes, :edges => @edges, :rootedge => @re )
+  end
+
+  def test_id
+    assert_equal( 'tree1', @tree.id )
+    @tree.id = 'tree2'
+    assert_equal( 'tree2', @tree.id )
+  end
+
+  def test_label
+    assert_nil( @tree.label )
+    @tree.label = 'a tree'
+    assert_equal( 'a tree', @tree.label )
+  end
+
+  def test_rootedge
+    assert_equal( @re, @tree.rootedge )
+    re = Bio::NeXML::RootEdge.new( 're2', :target => @n9 )
+    @tree.rootedge = re
+    assert_equal( re, @tree.rootedge )
+  end
+
+  def test_roots
+    @roots.each do |r|
+      assert @tree.roots.include?( r )
+    end
+  end
+
+  def test_add_node
+    node = Bio::NeXML::Node.new( 'node' )
+    @tree.add_node( node )
+    assert @tree.include?( node )
+    assert_equal( @tree, node.tree )
+  end
+
+  def test_add_edge
+    node1 = Bio::NeXML::Node.new( 'node1' )
+    node2 = Bio::NeXML::Node.new( 'node2' )
+    edge = Bio::NeXML::Edge.new( 'edge', :source => node1, :target => node2 )
+    @tree << node1 << node2 << edge
+
+    assert @tree.include?( edge )
+    assert_equal( @tree, edge.tree )
+  end
+
+  def test_delete_node
+    n = @nodes[ 2 ]
+    @tree.delete_node( n )
+    assert !@tree.include?( n )
+  end
+
+  def test_delete_edge
+    @tree.delete_edge( @edges[ 1 ] )
+    assert !@tree.include?( @edges[ 1 ] )
+  end
+
+  def test_append_operator
+    n10 = Bio::NeXML::Node.new( 'n10' )
+    e9 = Bio::NeXML::Edge.new( 'e9', :source => @n9, :target => n10 )
+
+    @tree << n10
+    @tree << e9
+
+    @tree.include?( n10 )
+    @tree.include?( e9 )
+  end
+
+  def test_get_node_by_id
+    assert_equal( @nodes[ 0 ], @tree.get_node_by_id( 'n2' ) )
+  end
+
+  def test_get_edge_by_id
+    assert_equal( @edges[ 0 ], @tree.get_edge_by_id( 'e12' ) )
+  end
+
+  def test_hash_notation
+    assert_equal( @nodes[ 0 ], @tree[ 'n2' ] )
+    assert_equal( @edges[ 0 ], @tree[ 'e12' ] )
+  end
+
+  def test_has_node
+    assert @tree.has_node?( @nodes[ 0 ] )
+    assert !@tree.has_node?( Bio::NeXML::Node.new( 'foo' ) )
+  end
+
+  def test_has_edge
+    assert @tree.has_edge?( @edges[ 0 ] )
+    assert !@tree.has_edge?( Bio::NeXML::Edge.new( 'foo' ) )
+  end
+
+  def test_include
+    assert @tree.include?( @nodes[ 0 ] )
+    assert @tree.include?( @edges[ 0 ] )
+  end
+
+  def test_each_node
+    c = 0
+    @tree.each_node do |n|
+      assert @tree.include?( n )
+      c +=1
+    end
+    assert @tree.number_of_nodes, c
+  end
+
+  def test_each_node_with_id
+    c = 0
+    @tree.each_node_with_id do |i, n|
+      assert @tree.include?( n )
+      assert_equal( n.id, i )
+      c +=1
+    end
+    assert @tree.number_of_nodes, c
+  end
+
+  def test_each_edge
+    c = 0
+    @tree.each_edge do |e|
+      assert @tree.include?( e )
+      c +=1
+    end
+    assert @tree.number_of_edges, c
+  end
+
+  def test_each_edge_with_id
+    c = 0
+    @tree.each_edge_with_id do |i, e|
+      assert @tree.include?( e )
+      assert_equal( e.id, i )
+      c +=1
+    end
+    assert @tree.number_of_edges, c
+  end
+end #end class TestTree
+
+class TestTrees < Test::Unit::TestCase
+
+  def setup
+    @otus = Bio::NeXML::Otus.new( 'o1' )
+    @tree = Bio::NeXML::Tree.new( 't1' )
+    @network = Bio::NeXML::Network.new( 'n1' )
+    @trees = Bio::NeXML::Trees.new( 'trees1', :label => 'Tree container' )
+    @trees.add_tree( @tree )
+    @trees.add_network( @network )
+  end
+
+  def test_id
+    @trees.id = 'trees2'
+    assert_equal( 'trees2', @trees.id )
+  end
+
+  def test_label
+    @trees.label = 'Label changed'
+    assert_equal( 'Label changed', @trees.label )
+  end
+
+  def test_hash_notation
+    assert_equal( @trees[ 't1' ], @tree )
+    assert_equal( @trees[ 'n1' ], @network )
+    assert_nil( @trees[ 'foo' ] )
+  end
+
+  def test_append_operator
+    tree = Bio::NeXML::Tree.new( 't2' )
+    network = Bio::NeXML::Tree.new( 'n2' )
+
+    @trees << tree << network
+
+    assert( @trees.include?( tree ) )
+    assert( @trees.include?( network ) )
+
+    assert_equal( @trees, tree.trees )
+    assert_equal( @trees, network.trees )
+  end
+
+  def test_trees
+    assert_equal( [ @tree ], @trees.trees )
+  end
+
+  def test_network
+    assert_equal( [ @network ], @trees.networks )
+  end
+
+  def test_add_tree
+    tree = Bio::NeXML::Tree.new( 't2' )
+    @trees << tree
+    assert( @trees.include?( tree ) )
+    assert_equal( @trees, tree.trees )
+  end
+
+  def test_add_network
+    network = Bio::NeXML::Tree.new( 'n2' )
+    @trees << network
+    assert( @trees.include?( network ) )
+    assert_equal( @trees, network.trees )
+  end
+
+  def test_has_tree?
+    assert( @trees.has_tree?( @tree ) )
+  end
+
+  def test_has_network?
+    assert( @trees.has_network?( @network ) )
+  end
+
+  def test_include?
+    assert( @trees.include?( @tree ) )
+    assert( @trees.include?( @network ) )
+    assert( !@trees.include?( Bio::NeXML::Tree.new( 'foo' ) ) )
+  end
+
+  def test_number_of_trees
+    assert_equal( 1, @trees.number_of_trees )
+  end
+
+  def test_number_of_networks
+    assert_equal( 1, @trees.number_of_networks )
+  end
+
+  def test_count
+    assert_equal 2, @trees.count
+  end
+
+  def test_get_tree_by_id
+    assert_not_nil @trees.get_tree_by_id 't1'
+    assert_nil @trees.get_tree_by_id 'foo'
+  end
+
+  def test_get_network_by_id
+    assert_not_nil @trees.get_network_by_id 'n1'
+    assert_nil @trees.get_network_by_id 'foo'
+  end
+
+  def test_each_tree
+    c = 0
+    @trees.each_tree {|t| c+=1 }
+    assert_equal 1, c
+  end
+
+  def test_each_network
+    c = 0
+    @trees.each_network {|t| c+=1 }
+    assert_equal 1, c
+  end
+
+  def test_each
+    c = 0
+    @trees.each {|t| c+=1 }
+    assert_equal 2, c
+  end
+
+end #end class TestTrees
+
+#class TestTree < Test::Unit::TestCase
+
+  #def setup
+    #@tree = Bio::NeXML::Tree.new 'tree'
+  #end
+
+  #def teardown
+    #@tree = nil
+  #end
+
+  #def test_add_rootedge
+    #target = Bio::NeXML::Node.new 'node1'
+    #re = Bio::NeXML::RootEdge.new 're1', target, 2
+    #@tree.add_rootedge re
+    #assert @tree.rootedge
+  #end
+
+  #def test_target_cache
+    #assert_instance_of Array, @tree.target_cache
+  #end
+
+#end