BioDSL 1.0.0

data/test/BioDSL/commands/test_classify_seq_mothur.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+# Test class for ClassifySeqMothur.
+class TestClassifySeqMothur < Test::Unit::TestCase
+  def setup
+    omit('mothur not found') unless BioDSL::Filesys.which('mothur')
+
+    @p = BP.new
+    @database = __FILE__
+    @taxonomy = __FILE__
+  end
+
+  test 'BioDSL::Pipeline#classify_seq_mothur with disallowed option fail' do
+    assert_raise(BioDSL::OptionError) do
+      @p.classify_seq_mothur(database: @database, taxonomy: @taxonomy,
+                             foo: 'bar')
+    end
+  end
+
+  test 'BioDSL::Pipeline#classify_seq_mothur w. allowed option dont fail' do
+    assert_nothing_raised do
+      @p.classify_seq_mothur(database: @database, taxonomy: @taxonomy, cpus: 2)
+    end
+  end
+
+  # test "BioDSL::Pipeline#classify_seq_mothur outputs correctly" do
+  #   # TODO: mock this sucker.
+  # end
+end

data/test/BioDSL/commands/test_clip_primer.rb

@@ -0,0 +1,377 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+# Test class for ClipPrimer.
+# rubocop:disable ClassLength
+class TestClipPrimer < Test::Unit::TestCase
+  def setup
+    @input, @output   = BioDSL::Stream.pipe
+    @input2, @output2 = BioDSL::Stream.pipe
+
+    @p = BioDSL::Pipeline.new
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with invalid options raises' do
+    assert_raise(BioDSL::OptionError) { @p.clip_primer(foo: 'bar') }
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with valid options dont raise' do
+    assert_nothing_raised do
+      @p.clip_primer(primer: 'atcg', direction: :forward)
+    end
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward full length match ' \
+    'returns correctly' do
+    @output.write(SEQ: 'TCGTATGCCGTCTTCTGCTT')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"",
+      | :SEQ_LEN=>0,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>0,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer status returns correctly' do
+    @output.write(SEQ: 'TCGTATGCCGTCTTCTGCTT')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    assert_equal(1, @p.status.first[:records_in])
+    assert_equal(1, @p.status.first[:records_out])
+    assert_equal(1, @p.status.first[:sequences_in])
+    assert_equal(1, @p.status.first[:sequences_out])
+    assert_equal(20, @p.status.first[:residues_in])
+    assert_equal(20, @p.status.first[:residues_out])
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse full length match ' \
+    'returns correctly' do
+    @output.write(SEQ: 'TCGTATGCCGTCTTCTGCTT')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"",
+      | :SEQ_LEN=>0,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>0,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer w. forward begin match returns OK' do
+    @output.write(SEQ: 'TCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actacgt",
+      | :SEQ_LEN=>7,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>0,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse begin match returns OK' do
+    @output.write(SEQ: 'TCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"",
+      | :SEQ_LEN=>0,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>0,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward middle match returns OK' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actacgt",
+      | :SEQ_LEN=>7,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse middle match returns OK' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actgactga",
+      | :SEQ_LEN=>9,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward end match returns OK' do
+    @output.write(SEQ: 'gactgaTCGTATGCCGTCTTCTGCTT')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"",
+      | :SEQ_LEN=>0,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>6,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse end match returns OK' do
+    @output.write(SEQ: 'gactgaTCGTATGCCGTCTTCTGCTT')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse).
+      run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"gactga",
+      | :SEQ_LEN=>6,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>6,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward middle match and ' \
+    'reverse_complement returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'AAGCAGAAGACGGCATACGA', direction: :forward,
+                   reverse_complement: true)
+    @p.run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actacgt",
+      | :SEQ_LEN=>7,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse middle match and ' \
+    'reverse_complement returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'AAGCAGAAGACGGCATACGA', direction: :reverse,
+                   reverse_complement: true)
+    @p.run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actgactga",
+      | :SEQ_LEN=>9,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward middle miss and ' \
+    'search_distance returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward,
+                   search_distance: 28)
+    @p.run(input: @input, output: @output2)
+
+    expected = '{:SEQ=>"actgactgaTCGTATGCCGTCTTCTGCTTactacgt"}'
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward middle match and ' \
+    'search_distance returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward,
+                   search_distance: 29)
+    @p.run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actacgt",
+      | :SEQ_LEN=>7,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse middle miss and ' \
+    'search_distance returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse,
+                   search_distance: 26).run(input: @input, output: @output2)
+
+    expected = '{:SEQ=>"actgactgaTCGTATGCCGTCTTCTGCTTactacgt"}'
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse middle match and ' \
+    'search_distance returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse,
+                   search_distance: 27).run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actgactga",
+      | :SEQ_LEN=>9,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with forward match and ' \
+    'search_distance longer than sequence returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward,
+                   search_distance: 70).run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actacgt",
+      | :SEQ_LEN=>7,
+      | :CLIP_PRIMER_DIR=>"FORWARD",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with reverse match and ' \
+    'search_distance longer than sequence returns correctly' do
+    @output.write(SEQ: 'actgactgaTCGTATGCCGTCTTCTGCTTactacgt')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :reverse,
+                   search_distance: 70).run(input: @input, output: @output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:SEQ=>"actgactga",
+      | :SEQ_LEN=>9,
+      | :CLIP_PRIMER_DIR=>"REVERSE",
+      | :CLIP_PRIMER_POS=>9,
+      | :CLIP_PRIMER_LEN=>20,
+      | :CLIP_PRIMER_PAT=>"TCGTATGCCGTCTTCTGCTT"}
+    EXP
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with sequence length shorter than ' \
+    'pattern returns correctly' do
+    @output.write(SEQ: 'actgactgaTC')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    expected = '{:SEQ=>"actgactgaTC"}'
+
+    assert_equal(expected, collect_result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::ClipPrimer with sequence length 0 returns OK' do
+    @output.write(SEQ: '')
+    @output.close
+    @p.clip_primer(primer: 'TCGTATGCCGTCTTCTGCTT', direction: :forward).
+      run(input: @input, output: @output2)
+
+    expected = '{:SEQ=>""}'
+
+    assert_equal(expected, collect_result.chomp)
+  end
+end

data/test/BioDSL/commands/test_cluster_otus.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+# Test class for ClusterOtus.
+class TestClusterOtus < Test::Unit::TestCase
+  def setup
+    omit('usearch not found') unless BioDSL::Filesys.which('usearch')
+  end
+
+  test 'BioDSL::Pipeline#cluster_otus with disallowed option raises' do
+    p = BioDSL::Pipeline.new
+    assert_raise(BioDSL::OptionError) { p.cluster_otus(foo: 'bar') }
+  end
+
+  test 'BioDSL::Pipeline#cluster_otus with allowed option dont raise' do
+    p = BioDSL::Pipeline.new
+    assert_nothing_raised { p.cluster_otus(identity: 1) }
+  end
+
+  test 'BioDSL::Pipeline#cluster_otus with SEQ and no SEQ_COUNT raises' do
+    input, output   = BioDSL::Stream.pipe
+    input2, output2 = BioDSL::Stream.pipe
+
+    output.write(one: 1, two: 2, three: 3)
+    output.write(SEQ: 'atcg')
+    output.write(SEQ: 'atcg')
+    output.close
+
+    p = BioDSL::Pipeline.new
+
+    assert_raise(BioDSL::SeqError) do
+      p.cluster_otus.run(input: input, output: output2)
+    end
+
+    input2.close
+  end
+
+  test 'BioDSL::Pipeline#cluster_otus with SEQ and unsorted SEQ_COUNT ' \
+    'raises' do
+    input, output   = BioDSL::Stream.pipe
+    input2, output2 = BioDSL::Stream.pipe
+
+    output.write(one: 1, two: 2, three: 3)
+    output.write(SEQ_COUNT: 3, SEQ: 'atcgatcgatcgatcgatcgatcgatcgtacgacgtagct')
+    output.write(SEQ_COUNT: 4, SEQ: 'atcgatcgatcgatcgatcgatcgatcgtacgacgtagct')
+    output.close
+
+    p = BioDSL::Pipeline.new
+
+    assert_raise(BioDSL::UsearchError) do
+      p.cluster_otus.run(input: input, output: output2)
+    end
+
+    input2.close
+  end
+
+  test 'BioDSL::Pipeline#cluster_otus outputs correctly' do
+    input, output   = BioDSL::Stream.pipe
+    @input2, output2 = BioDSL::Stream.pipe
+
+    output.write(one: 1, two: 2, three: 3)
+    output.write(SEQ_COUNT: 5, SEQ: 'atcgaAcgatcgatcgatcgatcgatcgtacgacgtagct')
+    output.write(SEQ_COUNT: 4, SEQ: 'atcgatcgatcgatcgatcgatcgatcgtacgacgtagct')
+    output.close
+
+    p = BioDSL::Pipeline.new.cluster_otus.run(input: input, output: output2)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:one=>1,
+      | :two=>2,
+      | :three=>3}
+      |{:SEQ_NAME=>"1",
+      | :SEQ=>"ATCGAACGATCGATCGATCGATCGATCGTACGACGTAGCT",
+      | :SEQ_LEN=>40,
+      | :SEQ_COUNT=>5}
+    EXP
+
+    assert_equal(expected, collect_result.delete("\n"))
+  end
+
+  test 'BioDSL::Pipeline#cluster_otus status outputs correctly' do
+    input, output   = BioDSL::Stream.pipe
+    input2, output2 = BioDSL::Stream.pipe
+
+    output.write(one: 1, two: 2, three: 3)
+    output.write(SEQ_COUNT: 5, SEQ: 'atcgaAcgatcgatcgatcgatcgatcgtacgacgtagct')
+    output.write(SEQ_COUNT: 4, SEQ: 'atcgatcgatcgatcgatcgatcgatcgtacgacgtagct')
+    output.close
+
+    p = BioDSL::Pipeline.new.cluster_otus.run(input: input, output: output2)
+
+    assert_equal(3,  p.status.first[:records_in])
+    assert_equal(2,  p.status.first[:records_out])
+    assert_equal(2,  p.status.first[:sequences_in])
+    assert_equal(1,  p.status.first[:sequences_out])
+    assert_equal(80, p.status.first[:residues_in])
+    assert_equal(40, p.status.first[:residues_out])
+  end
+end

data/test/BioDSL/commands/test_collapse_otus.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+# Test class for CollapseOtus.
+class TestCollapseOtus < Test::Unit::TestCase
+  def setup
+    @input, @output   = BioDSL::Stream.pipe
+    @input2, @output2 = BioDSL::Stream.pipe
+
+    @output.write(OTU: 'OTU_0', SAMPLE1_COUNT: 3352,
+                  TAXONOMY: 'Streptococcaceae(100);Lactococcus(100)')
+    @output.write(OTU: 'OTU_1', SAMPLE1_COUNT: 881,
+                  TAXONOMY: 'Leuconostocaceae(100);Leuconostoc(100)')
+    @output.write(OTU: 'OTU_2', SAMPLE1_COUNT: 228,
+                  TAXONOMY: 'Streptococcaceae(100);Lactococcus(100)')
+    @output.write(OTU: 'OTU_3', SAMPLE1_COUNT: 5,
+                  TAXONOMY: 'Pseudomonadaceae(100);Pseudomonas(100)')
+
+    @output.close
+
+    @p = BP.new
+  end
+
+  test 'BioDSL::Pipeline::Count with invalid options raises' do
+    assert_raise(BioDSL::OptionError) { @p.collapse_otus(foo: 'bar') }
+  end
+
+  test 'BioDSL::Pipeline::Count to file outputs correctly' do
+    @p.collapse_otus.run(input: @input, output: @output2)
+    expected = <<-EXP.gsub(/^\s+\|/, '').delete("\n")
+      |{:OTU=>"OTU_0",
+      | :SAMPLE1_COUNT=>3580,
+      | :TAXONOMY=>"Streptococcaceae(100);Lactococcus(100)"}
+      |{:OTU=>"OTU_1",
+      | :SAMPLE1_COUNT=>881,
+      | :TAXONOMY=>"Leuconostocaceae(100);Leuconostoc(100)"}
+      |{:OTU=>"OTU_3",
+      | :SAMPLE1_COUNT=>5,
+      | :TAXONOMY=>"Pseudomonadaceae(100);Pseudomonas(100)"}
+    EXP
+    assert_equal(expected, collect_result.delete("\n"))
+  end
+
+  test 'BioDSL::Pipeline::Count status outputs correctly' do
+    @p.collapse_otus.run(input: @input, output: @output2)
+
+    assert_equal(4, @p.status.first[:records_in])
+    assert_equal(3, @p.status.first[:records_out])
+    assert_equal(4, @p.status.first[:otus_in])
+    assert_equal(3, @p.status.first[:otus_out])
+  end
+end