scaffolder 0.4.4 → 0.5.0

data/test/helper.rb

@@ -1,30 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'redgreen'
-require 'mocha'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'scaffolder'
-
-class Test::Unit::TestCase
-  class << self
-
-    def should_have_method_attribute(klass)
-      should "have method #attribute" do
-        assert_respond_to( klass, :attribute )
-      end
-    end
-
-    def should_have_attribute(klass, *attributes)
-      attributes.each do |attribute|
-        should "have instance attribute #{attribute}" do
-          assert_respond_to( klass.new, attribute )
-        end
-      end
-    end
-
-  end
-end

data/test/test_insert.rb

@@ -1,77 +0,0 @@
-require 'helper'
-
-class TestInsert < Test::Unit::TestCase
-  context Scaffolder::Region::Insert do
-
-    context "attributes" do
-
-      should_have_attribute Scaffolder::Region::Insert, :source, :open, :close
-
-      setup do
-        @length = 15
-        @insert = Scaffolder::Region::Insert.new
-        @insert.raw_sequence('N' * @length)
-      end
-
-      should "return open plus sequence length as default close" do
-        @insert.open  5
-        assert_equal(@insert.close,@insert.open + @length - 1)
-      end
-
-      should "return close minus sequence length as default open" do
-        @insert.close 20
-        assert_equal(@insert.open,@insert.close - @length - 1)
-      end
-
-      should "include the insert position" do
-        @insert.open  5
-        @insert.close 10
-        assert_equal(@insert.position,4..9)
-      end
-
-      should "throw an error when neither open or close are provided" do
-        assert_raise(Scaffolder::Errors::CoordinateError){ @insert.position }
-      end
-
-    end
-
-    context "#size_diff" do
-
-      setup do
-        @insert = Scaffolder::Region::Insert.new
-        @insert.open  3
-        @insert.close 5
-      end
-
-      should "return a negative diff for a sequence smaller than insert site" do
-        @insert.raw_sequence 'TT'
-        assert_equal(@insert.size_diff,-1)
-      end
-
-      should "return 0 for a sequence equal to the insert site" do
-        @insert.raw_sequence 'TTT'
-        assert_equal(@insert.size_diff,0)
-      end
-
-      should "return a positive diff for a sequence larger than insert site" do
-        @insert.raw_sequence 'TTTT'
-        assert_equal(@insert.size_diff,1)
-      end
-
-    end
-
-    should "be comparable by close position" do
-      a = Scaffolder::Region::Insert.new
-      a.close 1
-
-      b = a.clone
-      b.close 2
-
-      c = b.clone
-      c.close 3
-
-      assert_equal([c,a,b].sort, [a,b,c])
-    end
-
-  end
-end

data/test/test_region.rb

@@ -1,151 +0,0 @@
-require 'helper'
-
-class TestScaffolder < Test::Unit::TestCase
-  context Scaffolder::Region do
-
-    context "adding instance methods with attribute method" do
-
-      setup do
-        @attr = :some_attribute
-      end
-
-      should "create a single accessor attribute" do
-        Scaffolder::Region.attribute @attr
-        methods = Scaffolder::Region.instance_methods.map{|m| m.to_s}
-        assert(methods.include?(@attr.to_s))
-      end
-
-      should "return nil until attribute value is stored" do
-        Scaffolder::Region.attribute @attr
-        region = Scaffolder::Region.new
-        assert_equal(region.send(@attr),nil)
-        region.send(@attr,5)
-        assert_equal(region.send(@attr),5)
-      end
-
-      should "allow specification of default value" do
-        Scaffolder::Region.attribute @attr, :default => 1
-        region = Scaffolder::Region.new
-        assert_equal(region.send(@attr),1)
-        region.send(@attr,5)
-        assert_equal(region.send(@attr),5)
-      end
-
-      should "allow specification of default value using a block" do
-        Scaffolder::Region.attribute @attr, :default => lambda{|s| s.entry_type }
-        region = Scaffolder::Region.new
-        assert_equal(region.send(@attr),region.entry_type)
-        region.send(@attr,5)
-        assert_equal(region.send(@attr),5)
-      end
-
-    end
-
-    context "passing the yaml hash to the generate method" do
-
-      setup do
-        Scaffolder::Region.attribute(:one)
-        Scaffolder::Region.attribute(:two)
-        @tags = {'one' => 1, 'two' => 2}
-      end
-
-      should "should call each tag in the hash as a method to store the value" do
-        Scaffolder::Region.any_instance.expects(:one).with(1)
-        Scaffolder::Region.any_instance.expects(:two).with(2)
-        Scaffolder::Region.generate(@tags)
-      end
-
-      should "return an instantiated region object" do
-        region = Scaffolder::Region.generate(@tags)
-        assert_equal(region.one,1)
-        assert_equal(region.two,2)
-      end
-
-      should "throw UnknownAttributeError for an unknown attribute" do
-        assert_raise Scaffolder::Errors::UnknownAttributeError do
-          Scaffolder::Region.generate({:three => 3})
-        end
-      end
-
-    end
-
-    context "attributes" do
-
-      should_have_attribute Scaffolder::Region,
-        :start, :stop, :reverse, :raw_sequence
-
-      should "return the class name as the entry type" do
-        Scaffolder::Region::NewRegion = Class.new(Scaffolder::Region)
-        assert_equal(Scaffolder::Region::NewRegion.new.entry_type,:newregion)
-      end
-
-      should "return 1 as default value for start attribute" do
-        sequence = Scaffolder::Region.new
-        assert_equal(sequence.start,1)
-      end
-
-      should "return #raw_sequence length as default value for stop attribute" do
-        length = 5
-        sequence = Scaffolder::Region.new
-        sequence.raw_sequence 'N' * length
-        assert_equal(sequence.stop,length)
-      end
-
-    end
-
-    context "generating the processed sequence" do
-
-      [:sequence_hook, :raw_sequence].each do |method|
-
-        context "using the #{method} method" do
-
-          setup do
-            # Test class to prevent interference with other tests
-            @s = Class.new(Scaffolder::Region).new
-            @s.class.send(:define_method,method,lambda{'ATGCCAGATAACTGACTAGCATG'})
-          end
-
-          should "return the sequence when no other options are passed" do
-            assert_equal(@s.sequence,'ATGCCAGATAACTGACTAGCATG')
-          end
-
-          should "reverse complement sequence when passed the reverse option" do
-            @s.reverse true
-            assert_equal(@s.sequence, 'CATGCTAGTCAGTTATCTGGCAT')
-          end
-
-          should "create subsequence when passed sequence coordinates" do
-            @s.start 5
-            @s.stop 20
-            assert_equal(@s.sequence,'CAGATAACTGACTAGC')
-          end
-
-          should "raise a CoordinateError when start is less than 1" do
-            @s.start 0
-            assert_raise(Scaffolder::Errors::CoordinateError){ @s.sequence }
-          end
-
-          should "raise a CoordinateError when stop is greater than sequence " do
-            @s.stop 24
-            assert_raise(Scaffolder::Errors::CoordinateError){ @s.sequence }
-          end
-
-          should "raise a CoordinateError when stop is greater than start " do
-            @s.start 6
-            @s.stop 5
-            assert_raise(Scaffolder::Errors::CoordinateError){ @s.sequence }
-          end
-
-        end
-
-      end
-
-    end
-
-    should "instantiate return corresponding region subclass when requested" do
-      Scaffolder::Region::Type = Class.new
-      assert_equal(Scaffolder::Region['type'],Scaffolder::Region::Type)
-    end
-
-  end
-end

data/test/test_scaffolder.rb

@@ -1,116 +0,0 @@
-require 'helper'
-
-class TestScaffolder < Test::Unit::TestCase
-  context Scaffolder do
-
-    Scaffolder::Region::Mock = Class.new(Scaffolder::Region)
-
-    setup do
-      @sequence = nil
-      @data = [{'mock' => Hash.new}]
-    end
-
-    context 'parsing a scaffold file' do
-
-      setup do
-        Bio::FlatFile.stubs(:auto).with(@sequence).returns({})
-      end
-
-      should "fetch correct region class type" do
-        Scaffolder::Region.expects(:'[]').with('mock').returns(Scaffolder::Region::Mock)
-        Scaffolder.new(@data,@sequence)
-      end
-
-      should "pass data to region object" do
-        Scaffolder::Region::Mock.expects(:generate).with(@data.first['mock'])
-        Scaffolder.new(@data,@sequence)
-      end
-
-    end
-
-    context 'parsing a scaffold file with a source keyword' do
-
-      setup do
-        Bio::FlatFile.stubs(:auto).with(@sequence).returns([
-          stub(:definition => 'seq1', :seq => 'ATGC')])
-      end
-
-      should "should also pass raw_sequence from flat file" do
-        @data.first['mock']['source'] = 'seq1'
-        Scaffolder::Region::Mock.any_instance.expects(:source).with('seq1')
-        Scaffolder::Region::Mock.any_instance.expects(:raw_sequence).with('ATGC')
-        Scaffolder.new(@data,@sequence)
-      end
-
-    end
-
-    context 'updating each data hash with raw_sequence attributes' do
-
-      setup do
-        @seqs = {'seq1' => 'AAA'}
-        @expected = {'source' => 'seq1', 'raw_sequence' => @seqs['seq1']}
-      end
-
-      should "do nothing when no source keyword" do
-        test = {'something' => 'nothing'}
-        assert_equal(test,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to simple hash" do
-        test = {'source' => 'seq1'}
-        assert_equal(@expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to a nested hash" do
-        test     = {'something' => {'source' => 'seq1'}}
-        expected = {'something' => @expected}
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to a twice nested hash" do
-        test     = {'something' => {'other' => {'source' => 'seq1'}}}
-        expected = {'something' => {'other' => @expected}}
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to simple hash inside an array" do
-        test     = [{'source' => 'seq1'}]
-        expected = [@expected]
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to a nested hash inside an array" do
-        test     = {'something' => [{'source' => 'seq1'}]}
-        expected = {'something' => [@expected]}
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to two nested hashes inside an array" do
-        test     = {'something' => [{'source' => 'seq1'},{'source' => 'seq1'}]}
-        expected = {'something' => [@expected,@expected]}
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to a hash inside a hash inside an array" do
-        test     = {'something' => [{'else' => {'source' => 'seq1'}}]}
-        expected = {'something' => [{'else' => @expected}]}
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "add raw_sequence to a twice nested (hash inside an array)" do
-        test     = {'something' => [{'else' => [{'source' => 'seq1'}]}]}
-        expected = {'something' => [{'else' => [@expected]}]}
-        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
-      end
-
-      should "throw an UnknownSequenceError when no matching sequence" do
-        test = {'source' => 'non_existent_sequence'}
-        assert_raise(Scaffolder::Errors::UnknownSequenceError) do
-          Scaffolder.update_with_sequence(test,@seqs)
-        end
-      end
-
-    end
-
-  end
-end

data/test/test_sequence.rb

@@ -1,107 +0,0 @@
-require 'helper'
-
-class TestSequence < Test::Unit::TestCase
-  context Scaffolder::Region::Sequence do
-
-    context "attributes" do
-      should_have_method_attribute Scaffolder::Region::Sequence
-      should_have_attribute Scaffolder::Region::Sequence, :source, :inserts
-    end
-
-    context "insert attribute method" do
-
-      setup do
-        @sequence = Scaffolder::Region::Sequence.new
-        @hash = {'open' => 2, 'close' => 3}
-        @insert = Scaffolder::Region::Insert.new
-        @insert.open  @hash['open']
-        @insert.close @hash['close']
-      end
-
-      should "return empty array as default value" do
-        assert_equal(@sequence.inserts,Array.new)
-      end
-
-      should "allow array of inserts to be set as value" do
-        @sequence.inserts [@insert]
-        assert_equal(@sequence.inserts,[@insert])
-      end
-
-      should "process insert data hash into an array of inserts" do
-        @sequence.inserts [@hash]
-        insert = @sequence.inserts.first
-        assert_instance_of(Scaffolder::Region::Insert,insert)
-        assert_equal(@hash['close'],insert.close)
-        assert_equal(@hash['open'],insert.open)
-      end
-
-      should "process mixed insert data into an array of inserts" do
-        @sequence.inserts [@hash,@insert]
-        @sequence.inserts.each do |insert|
-          assert_instance_of(Scaffolder::Region::Insert,insert)
-          assert_equal(@hash['close'],insert.close)
-          assert_equal(@hash['open'],insert.open)
-        end
-      end
-
-    end
-
-    context "with inserts added" do
-
-      setup do
-        @sequence = Scaffolder::Region::Sequence.new
-        @sequence.raw_sequence 'ATGCCAGATAACTGACTAGCATG'
-
-        @insert = Scaffolder::Region::Insert.new
-        @insert.raw_sequence 'GGTAGTA'
-        @insert.open  5
-        @insert.close 10
-      end
-
-      should "raise when the insert open is after the sequence stop" do
-        @insert.open 24
-        @insert.close 25
-        @sequence.inserts [@insert]
-        assert_raise(Scaffolder::Errors::CoordinateError){ @sequence.sequence }
-      end
-
-      should "raise when the insert close is before the sequence start" do
-        @insert.open -5
-        @insert.close 0
-        @sequence.inserts [@insert]
-        assert_raise(Scaffolder::Errors::CoordinateError){ @sequence.sequence }
-      end
-
-      should "raise when the insert open is greater than the insert close" do
-        @insert.open 11
-        @sequence.inserts [@insert]
-        assert_raise(Scaffolder::Errors::CoordinateError){ @sequence.sequence }
-      end
-
-      should "update the sequence with a simple insert" do
-        @sequence.inserts [@insert]
-        assert_equal(@sequence.sequence,'ATGCGGTAGTAACTGACTAGCATG')
-      end
-
-      should "update the sequence with a simple insert with repeated method calls" do
-        @sequence.inserts [@insert]
-        assert_equal(@sequence.sequence,'ATGCGGTAGTAACTGACTAGCATG')
-        assert_equal(@sequence.sequence,'ATGCGGTAGTAACTGACTAGCATG')
-      end
-
-      should "update the sequence stop position after adding a simple insert" do
-        @sequence.inserts [@insert]
-        assert_equal(@sequence.stop,24)
-      end
-
-      should "update sequence with inserts in reverse order" do
-        insert_two = @insert.clone
-        insert_two.open 12
-        insert_two.close 15
-        @sequence.inserts [@insert,insert_two]
-        assert_equal(@sequence.sequence,"ATGCGGTAGTAAGGTAGTACTAGCATG")
-      end
-    end
-
-  end
-end