scaffolder-tools 0.1.0

data/spec/scaffolder/tool/sequence_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','spec_helper'))
+
+describe Scaffolder::Tool::Sequence do
+
+  it "should inherit from Scaffolder::Tool" do
+    described_class.superclass.should == Scaffolder::Tool
+  end
+
+  it "should return the description of the tool" do
+    desc = "Generate the fasta output for the scaffold"
+    described_class.description.should == desc
+  end
+
+  describe "execution when correctly instantiated" do
+
+    before(:each) do
+      entries = [{:name => 'seq1', :nucleotides => 'ATGC'}]
+
+      @scaffold_file = File.new("scaffold",'w').path
+      @sequence_file = File.new("sequence",'w').path
+
+      write_scaffold_file(entries,@scaffold_file)
+      write_sequence_file(entries,@sequence_file)
+      settings = mock_command_line_settings(@scaffold_file,@sequence_file,{
+        :definition => nil,:no => nil})
+
+      tool = described_class.new(settings)
+      @output = StringIO.new(tool.execute)
+    end
+
+    after(:each) do
+      File.delete @scaffold_file, @sequence_file
+    end
+
+    it "should return the expected sequence" do
+      Bio::FlatFile.auto(@output).first.seq.should == 'ATGC'
+    end
+
+  end
+
+end

data/spec/scaffolder/tool/validate_spec.rb

@@ -0,0 +1,167 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','spec_helper'))
+
+describe Scaffolder::Tool::Validate do
+
+  it "should inherit from Scaffolder::Tool" do
+    described_class.superclass.should == Scaffolder::Tool
+  end
+
+  it "should return the description of the tool" do
+    desc = "Validate scaffold for overlapping inserts"
+    described_class.description.should == desc
+  end
+
+  describe "comparing inserts for overlaps" do
+
+    before(:all) do
+      @insert = stub(:position => 5..10)
+    end
+
+    it "should be false when inserts don't overlap" do
+      no_overlap = stub(:position => 11..12)
+      described_class.inserts_overlap?(@insert,no_overlap).should be_false
+      described_class.inserts_overlap?(no_overlap,@insert).should be_false
+    end
+
+    it "should be true when inserts do overlap" do
+      overlap = stub(:position => 10..11)
+      described_class.inserts_overlap?(@insert,overlap).should be_true
+      described_class.inserts_overlap?(overlap,@insert).should be_true
+    end
+
+  end
+
+  describe "testing a sequence for overlapping inserts" do
+
+    before(:all) do
+      # Use integers for mocks because they can be easily sorted
+      @a = 1; @b = 2
+      @sequence = stub(:inserts => [@a,@b])
+    end
+
+    it "should return an empty array when sequence has no errors" do
+      described_class.stubs(:inserts_overlap?).with(@a,@b).returns(false)
+      described_class.stubs(:inserts_overlap?).with(@b,@a).returns(false)
+      described_class.sequence_errors(@sequence).empty?.should be_true
+    end
+
+    it "should return inserts when sequence inserts overlap" do
+      described_class.stubs(:inserts_overlap?).with(@a,@b).returns(true)
+      described_class.stubs(:inserts_overlap?).with(@b,@a).returns(true)
+      described_class.sequence_errors(@sequence).should == [[@a,@b]].sort
+    end
+
+  end
+
+  describe "validating each entry in the scaffold" do
+
+    before(:each) do
+      @valid        = stub(:entry_type => :sequence)
+      @invalid      = @valid.clone
+      described_class.stubs(:sequence_errors).with(@valid).returns([])
+      described_class.stubs(:sequence_errors).with(@invalid).returns([nil])
+    end
+
+    subject do
+      described_class.new(mock_command_line_settings)
+    end
+
+    it "should return an empty array when scaffold is valid" do
+      subject.expects(:scaffold).returns([@valid,@valid])
+      subject.errors.should be_empty
+    end
+
+    it "should return invalid entries when scaffold is invalid" do
+      subject.expects(:scaffold).returns([@invalid,@valid])
+      subject.errors.should == [@invalid]
+    end
+
+    it "should ignore entries which are not sequences" do
+      @non_sequence = stub(:entry_type => :other)
+      subject.expects(:scaffold).returns([@invalid,@valid,@non_sequence])
+      subject.errors.should == [@invalid]
+    end
+
+  end
+
+  describe "scaffold validation with no overlapping inserts" do
+
+    subject do
+      validate = described_class.new(mock_command_line_settings)
+      validate.stubs(:errors).returns([])
+      validate
+    end
+
+    it "should not raise any errors" do
+      lambda{ subject.execute }.should_not raise_error
+    end
+
+    it "should not return anything" do
+      subject.execute.should == nil
+    end
+
+  end
+
+  describe "returning errors using the errors method" do
+
+    subject do
+      validate = described_class.new(mock_command_line_settings)
+
+      sequence = stub(:source => :seq1)
+      validate.stubs(:errors).returns([sequence])
+      described_class.stubs(:sequence_errors).with(sequence).returns(
+        [[stub(:open => 1,:close => 2, :source => 'some_insert')]])
+
+      validate
+    end
+
+    it "should not raise an error" do
+      lambda{ subject.execute }.should_not raise_error
+    end
+
+    it "should return a string" do
+      subject.execute.should be_instance_of(String)
+    end
+
+    it "should be an array when YAML is parsed" do
+      lambda{ YAML.load(subject.execute) }.should_not raise_error
+      YAML.load(subject.execute).should be_instance_of(Array)
+    end
+
+  end
+
+  describe "the attributes of the error data" do
+
+    subject do
+      validate = described_class.new(mock_command_line_settings)
+      @err = {:open => 1,:close => 2,:source => 'some_insert'}
+
+      sequence = stub(:source => 'seq1')
+      validate.stubs(:errors).returns([sequence])
+      described_class.stubs(:sequence_errors).with(sequence).returns([[stub(@err)]])
+
+      YAML.load(validate.execute).first['sequence-insert-overlap']
+    end
+
+    it "should name each overlap entry 'sequence-insert-overlap'" do
+      subject.should_not be_nil
+    end
+
+    it "should provide the name of overlap containing sequence" do
+      subject['source'].should == 'seq1'
+    end
+
+    it "should provide an array of the overlapping inserts" do
+      subject['inserts'].should be_instance_of(Array)
+    end
+
+    it "should provide the coordinates of the overlapping inserts" do
+      error = subject['inserts'].first
+      error['open'].should   == @err[:open]
+      error['close'].should  == @err[:close]
+      error['source'].should == @err[:source]
+    end
+
+  end
+
+end

data/spec/scaffolder/tool_index_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe Scaffolder::ToolIndex do
+
+  before(:each) do
+    @help_tool = Scaffolder::Tool::Help
+
+    @tool_class = Class.new(Scaffolder::Tool)
+    @tool_name = 'type'
+    Scaffolder::Tool.const_set(@tool_name.capitalize,@tool_class)
+
+    @args = OpenStruct.new({ :rest => %W|#{@tool_name} arg1 arg2| })
+  end
+
+  after(:each) do
+    Scaffolder::Tool.send(:remove_const,'Type')
+  end
+
+  subject do
+    object = Object.new
+    object.extend described_class
+    object
+  end
+
+  describe "tool_exists? method" do
+
+    it "should return false when no such tool exists" do
+      subject.tool_exists?('unknown-tool').should be_false
+    end
+
+    it "should return true when the tool exists" do
+      subject.tool_exists?(@tool_name).should be_true
+    end
+
+  end
+
+  describe "get_tool method" do
+
+    it "should return nil when no such tool exists" do
+      subject.get_tool('unknown-tool').should be_nil
+    end
+
+    it "should return the tool class when the tool exists" do
+      subject.get_tool(@tool_name).should == @tool_class
+    end
+
+  end
+
+end

data/spec/scaffolder/tool_spec.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe Scaffolder::Tool do
+
+  describe "initialisation with attributes" do
+
+    before(:each) do
+      @settings = mock_command_line_settings
+    end
+
+    subject do
+      Scaffolder::Tool.new(@settings)
+    end
+
+    its(:scaffold_file){ should ==  @settings.scaffold_file }
+    its(:sequence_file){ should ==  @settings.sequence_file }
+    its(:settings){ should ==  @settings }
+  end
+
+  describe "the run method" do
+
+    before(:all) do
+      @settings = mock_command_line_settings
+    end
+
+    before(:each) do
+      @message = "output\n"
+      @out = StringIO.new
+      @err = StringIO.new
+    end
+
+    subject do
+      Scaffolder::Tool.new(@settings)
+    end
+
+    it "should print to standard out when there are no errors" do
+      subject.expects(:execute).returns(@message)
+      lambda{ subject.run(@out,@err) }.should raise_error
+      @err.string.should == ""
+      @out.string.should == @message
+    end
+
+    it "should print nothing to standard out when there no error and no output" do
+      subject.expects(:execute).returns(nil)
+      lambda{ subject.run(@out,@err) }.should raise_error
+      @err.string.should == ""
+      @out.string.should == ""
+    end
+
+    it "should give a zero exit code when there are no errors" do
+      subject.expects(:execute).returns(@message)
+      lambda{ subject.run(@out,@err) }.should exit_with_code(0)
+    end
+
+    it "should print to standard error when there are errors" do
+      subject.expects(:execute).raises(Exception, @message)
+      lambda{ subject.run(@out,@err) }.should raise_error
+      @out.string.should == ""
+      @err.string.should == "Error. #{@message}"
+    end
+
+    it "should give a non-zero exit code when there are errors" do
+      subject.expects(:execute).raises(Exception, @message)
+      lambda{ subject.run(@out,@err) }.should exit_with_code(1)
+    end
+
+  end
+
+  describe "error checking with the scaffold method" do
+
+    before(:each) do
+      FakeFS.activate!
+
+      @scaffold_file = File.new('scaffold','w').path
+      File.open(@scaffold_file,'w'){|out| out.write "some_content" }
+
+      @sequence_file = File.new('sequence','w').path
+      File.open(@sequence_file,'w'){|out| out.write "some_content" }
+
+      @empty_file = File.new('empty_file','w').path
+      File.open(@empty_file,'w'){|out| out.write "" }
+
+      @missing_file = "file"
+    end
+
+    after(:each) do
+      FakeFS.deactivate!
+    end
+
+    it "should raise an error if the sequence file is missing" do
+      settings = mock_command_line_settings(@scaffold_file,@missing_file)
+      tool = Scaffolder::Tool.new(settings)
+      lambda{ tool.scaffold }.should raise_error(ArgumentError,
+        "Sequence file not found: #{@missing_file}")
+    end
+
+    it "should raise an error if the sequence file is empty" do
+      settings = mock_command_line_settings(@scaffold_file,@empty_file)
+      tool = Scaffolder::Tool.new(settings)
+      lambda{ tool.scaffold }.should raise_error(ArgumentError,
+        "Sequence file is empty: #{@empty_file}")
+    end
+
+    it "should raise an error if the scaffold file is missing" do
+      settings = mock_command_line_settings(@missing_file,@sequence_file)
+      tool = Scaffolder::Tool.new(settings)
+      lambda{ tool.scaffold }.should raise_error(ArgumentError,
+        "Scaffold file not found: #{@missing_file}")
+    end
+
+    it "should raise an error if the scaffold file is empty" do
+      settings = mock_command_line_settings(@empty_file,@sequence_file)
+      tool = Scaffolder::Tool.new(settings)
+      lambda{ tool.scaffold }.should raise_error(ArgumentError,
+        "Scaffold file is empty: #{@empty_file}")
+    end
+  end
+
+  describe "creating the scaffold with the scaffold method" do
+
+    before(:each) do
+      entries = [{:name => 'seq1', :nucleotides => 'ATGC'}]
+
+      @scaffold_file = File.new('scaffold','w').path
+      @sequence_file = File.new('sequence','w').path
+      write_scaffold_file(entries,@scaffold_file)
+      write_sequence_file(entries,@sequence_file)
+    end
+
+    after(:each) do
+      File.delete @scaffold_file, @sequence_file
+    end
+
+    subject do
+      Scaffolder::Tool.new(
+        mock_command_line_settings(@scaffold_file,@sequence_file))
+    end
+
+    it "should produce the expected sequence scaffold" do
+      subject.scaffold.length.should == 1
+      subject.scaffold.first.entry_type.should == :sequence
+      subject.scaffold.first.sequence.should == 'ATGC'
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'tempfile'
+require 'ostruct'
+
+require 'hashie'
+require 'rspec'
+require 'fakefs/safe'
+require 'mocha'
+require 'bio'
+require 'scaffolder/test/helpers'
+require 'scaffolder'
+
+require 'scaffolder/tool'
+require 'scaffolder/tool_index'
+require 'scaffolder/binary_helper'
+Dir["#{File.dirname(__FILE__)}/../lib/scaffolder/tool/*.rb"].each do |f|
+  require File.expand_path(f)
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
+  require File.expand_path(f)
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  include Scaffolder::Test::Helpers
+
+  def tool_subclasses
+    ObjectSpace.each_object.map{|obj| obj.class }.select do |cls|
+      cls.superclass == Scaffolder::Tool
+    end
+  end
+
+  def mock_command_line_settings(scaf_file = mock, seq_file = mock, hash_args={})
+    settings = mock
+
+    settings.stubs(:rest).returns([scaf_file,seq_file])
+    settings.stubs(:sequence_file).returns(seq_file)
+    settings.stubs(:scaffold_file).returns(scaf_file)
+
+    hash_args.each do |key,value|
+      settings.expects(:[]).with(key).returns(value)
+    end
+
+    settings
+  end
+
+end

data/spec/support/exit_code_matcher.rb

@@ -0,0 +1,26 @@
+# See: How can I validate exits and aborts in RSpec?
+# http://stackoverflow.com/questions/1480537
+
+module ExitCodeMatchers
+  RSpec::Matchers.define :exit_with_code do |code|
+    actual = nil
+    match do |block|
+      begin
+        block.call
+      rescue SystemExit => e
+        actual = e.status
+      end
+      actual and actual == code
+    end
+    failure_message_for_should do |block|
+      "expected block to call exit(#{code}) but exit" +
+        (actual.nil? ? " not called" : "(#{actual}) was called")
+    end
+    failure_message_for_should_not do |block|
+      "expected block not to call exit(#{code})"
+    end
+    description do
+      "expect block to call exit(#{code})"
+    end    
+  end  
+end