finishm 0.0.1

data/spec/c_node_finder_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe 'c_probe_node_finder' do
+  it 'should find set of probe nodes' do
+    Dir.mktmpdir do |tmpdir|
+      probes = [
+        'AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC',
+        'ACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGCGTAACGCGTATGCAATCTGCCTTGTACTAAGGGATAGCCCAGAGA',
+        ]
+      read_inputs = Bio::FinishM::ReadInput.new
+      read_inputs.fasta_singles_gz = [
+        File.join(File.dirname(__FILE__),'data','gapfilling','3','reads.fa.gz')
+        ]
+      probed_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probes, read_inputs, {
+        :assembly_coverage_cutoff => 0,
+        :velvet_kmer_size => 31,
+        #:output_assembly_path => '/tmp/v',
+        :output_assembly_path => tmpdir,
+        })
+
+      finder = Bio::FinishM::CProbeNodeFinder.new
+      read_probing_graph = Bio::Velvet::Underground::Graph.parse_from_file File.join(TEST_DATA_DIR,'c_probe_node_finder','1','LastGraph')
+      finder.find_probe_nodes(read_probing_graph, [4,5,6]).should == [1]
+      finder.find_probe_nodes(read_probing_graph, [515,135]).should == [3,4]
+    end
+  end
+
+  it 'should return the same as the Ruby node_finder' do
+    Dir.mktmpdir do |tmpdir|
+      probes = [
+        'AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC',
+        'ACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGCGTAACGCGTATGCAATCTGCCTTGTACTAAGGGATAGCCCAGAGA',
+        ]
+      read_inputs = Bio::FinishM::ReadInput.new
+      read_inputs.fasta_singles_gz = [
+        File.join(File.dirname(__FILE__),'data','gapfilling','3','reads.fa.gz')
+        ]
+      # First assembly run is fine
+      probed_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probes, read_inputs, {
+        :assembly_coverage_cutoff => 0,
+        :velvet_kmer_size => 31,
+        :output_assembly_path => tmpdir,
+        })
+
+      finder = Bio::FinishM::CProbeNodeFinder.new
+      read_probing_graph = Bio::Velvet::Underground::Graph.parse_from_file File.join(TEST_DATA_DIR,'c_probe_node_finder','1','LastGraph')
+      probes = finder.find_probes(read_probing_graph, [1,544])
+      probes[0][0].node_id.should == 1
+      probes[1][0].node_id.should == 2
+      probes[0][1].should == true
+      probes[1][1].should == false
+      probes[0][2].read_id.should == 1
+      probes[1][2].read_id.should == 544
+
+      finder.find_probes(read_probing_graph, []).should == []
+    end
+  end
+end

data/spec/connection_interpreter_spec.rb

@@ -0,0 +1,284 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class GraphTesting
+  def self.create_connection(first_second,distance=10)
+    doing_first = true
+    probes = first_second.collect do |namer|
+      if namer.kind_of?(Fixnum)
+        probe = Bio::FinishM::ConnectionInterpreter::Probe.new
+        probe.sequence_index = namer
+        if doing_first
+          probe.side = :end
+          doing_first = false
+        else
+          probe.side = :start
+        end
+        probe #'return'
+
+      elsif matches = namer.match(/^(.+)([se])$/)
+        probe = Bio::FinishM::ConnectionInterpreter::Probe.new
+        probe.sequence_index = matches[1].to_i
+        probe.side = matches[2] == 's' ? :start : :end
+        probe #'return'
+      else
+        raise namer
+      end
+    end
+    conn = Bio::FinishM::ConnectionInterpreter::Connection.new
+    conn.probe1 = probes[0]
+    conn.probe2 = probes[1]
+    conn.distance = distance
+    return conn
+  end
+
+  def self.create_connections(array_of_conn_strings)
+    conns = array_of_conn_strings.collect{|a| create_connection a}
+    seqs = {}
+    conns.each_with_index do |conn, i|
+      [conn.probe1, conn.probe2].each_with_index do |probe, j|
+        seqs[probe.sequence_index] ||= (['A']*10).join
+      end
+    end
+    return conns, seqs
+  end
+end
+
+describe "ConnectionInterpreter" do
+  it 'should find doubly_single_contig_connections hello world' do
+    conns, seqs = GraphTesting.create_connections([
+      %w(1s 3e)
+      ])
+    Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs
+      ).doubly_single_contig_connections.collect{|c| c.to_s}.should == [
+        '1s/3e:10'
+        ]
+  end
+
+  it 'should find inter-contig connections in a loop' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      [2,3],
+      [3,1],
+      ])
+    Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      ).doubly_single_contig_connections.collect{|c| c.to_s}.sort.should == [
+        '1e/2s:10',
+        '2e/3s:10',
+        '3e/1s:10',
+        ].sort
+  end
+
+  it 'should not include all connections in inter-contig connections' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      [2,3],
+      [3,4],
+      [3,5],
+      ])
+    Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      ).doubly_single_contig_connections.collect{|c| c.to_s}.sort.should == [
+        '1e/2s:10',
+        '2e/3s:10',
+        ].sort
+  end
+
+  it 'should be able to handle loops where there is only one contig' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,1],
+      ])
+    Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      ).doubly_single_contig_connections.collect{|c| c.to_s}.sort.should == [
+        '1e/1s:10',
+        ].sort
+  end
+
+  it 'should scaffold hello world' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      ])
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+    observed.should be_kind_of(Array)
+    observed.length.should == 1
+    o = observed[0]
+    o.should be_kind_of(Bio::FinishM::ConnectionInterpreter::Scaffold)
+    o.contigs.collect{|c| c.sequence_index}.should == [1,2]
+    o.contigs.collect{|c| c.direction}.should == [true, true]
+    o.gap_lengths.should === [10]
+    o.sequence(seqs).should == 'AAAAAAAAAANNNNNNNNNNAAAAAAAAAA'
+    observed.collect{|o| o.circular?}.uniq.should == [false]
+  end
+
+  it 'should scaffold 3 contigs together' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      [2,3],
+      ])
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+    observed.should be_kind_of(Array)
+    observed.length.should == 1
+    o = observed[0]
+    o.should be_kind_of(Bio::FinishM::ConnectionInterpreter::Scaffold)
+    o.sequence(seqs).should == 'AAAAAAAAAANNNNNNNNNNAAAAAAAAAANNNNNNNNNNAAAAAAAAAA'
+    o.contigs.collect{|c| c.sequence_index}.should == [1,2,3]
+    o.contigs.collect{|c| c.direction}.should == [true, true, true]
+    observed.collect{|o| o.circular?}.uniq.should == [false]
+  end
+
+  it 'should scaffold two separate scaffolds and a leftover' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      [3,4],
+      ])
+    seqs[99] = 'ATGC'
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+
+    observed.should be_kind_of(Array)
+    observed.length.should == 3
+    o = observed[0]
+    o.should be_kind_of(Bio::FinishM::ConnectionInterpreter::Scaffold)
+    o.sequence(seqs).should == 'AAAAAAAAAANNNNNNNNNNAAAAAAAAAA'
+    o.contigs.collect{|c| c.sequence_index}.should == [1,2]
+    o.contigs.collect{|c| c.direction}.should == [true, true]
+    o = observed[1]
+    o.should be_kind_of(Bio::FinishM::ConnectionInterpreter::Scaffold)
+    o.sequence(seqs).should == 'AAAAAAAAAANNNNNNNNNNAAAAAAAAAA'
+    o.contigs.collect{|c| c.sequence_index}.should == [3,4]
+    o.contigs.collect{|c| c.direction}.should == [true, true]
+    o = observed[2]
+    o.should be_kind_of(Bio::FinishM::ConnectionInterpreter::Scaffold)
+    o.contigs[0].sequence_index.should == 99
+    o.sequence(seqs).should == 'ATGC'
+    observed.collect{|o| o.circular?}.uniq.should == [false]
+  end
+
+  it 'should scaffold single contig circular scaffolds' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,1],
+      ])
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+
+    observed.should be_kind_of(Array)
+    observed.length.should == 1
+    o = observed[0]
+    o.should be_kind_of(Bio::FinishM::ConnectionInterpreter::Scaffold)
+    o.sequence(seqs).should == 'AAAAAAAAAA'
+    o.contigs.collect{|c| c.sequence_index}.should == [1]
+    o.contigs.collect{|c| c.direction}.should == [true]
+    o.circular?.should == true
+  end
+
+  it 'should scaffold multi-contig circular scaffolds' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      [2,3],
+      [3,1],
+      [9,10],
+      ])
+    seqs[87] = 'ATGC'
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+
+    observed.length.should == 3
+    observed.collect{|o| o.circular?}.should == [true, false, false]
+    observed[0].contigs.collect{|c| c.sequence_index}.should == [3,1,2]
+  end
+
+  it 'should respect the given distance given in the Connection' do
+    conns, seqs = GraphTesting.create_connections([
+      %w(1s 3e)
+      ])
+    conns[0].distance = 5
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+    observed.length.should == 1
+    observed[0].gap_lengths.should == [5]
+  end
+
+  it 'should be able to handle reverse scaffolding' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      ])
+    conns[0].probe1.side = :start #reverse both contigs
+    conns[0].probe2.side = :end
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, seqs.keys
+      )
+    observed = interpreter.scaffolds(interpreter.doubly_single_contig_connections)
+    observed.length.should == 1
+    observed[0].sequence(seqs).should == 'TTTTTTTTTTNNNNNNNNNNTTTTTTTTTT'
+  end
+
+  it 'should report unconnected probes' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      ])
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, [1,2]
+      )
+    interpreter.unconnected_probes.collect{|pro| pro.to_settable}.should == [
+      [1, :start],
+      [2, :end],
+      ]
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, [1,2,3]
+      )
+    interpreter.unconnected_probes.collect{|pro| pro.to_settable}.should == [
+      [1, :start],
+      [2, :end],
+      [3, :start],
+      [3, :end]
+      ]
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, [1,2,4]
+      )
+    interpreter.unconnected_probes.collect{|pro| pro.to_settable}.should == [
+      [1, :start],
+      [2, :end],
+      [4, :start],
+      [4, :end]
+      ]
+  end
+
+  it 'should report unconnected sequences' do
+    conns, seqs = GraphTesting.create_connections([
+      [1,2],
+      ])
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, [1,2]
+      )
+    interpreter.unconnected_sequences.should == [
+      ]
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, [1,2,3]
+      )
+    interpreter.unconnected_sequences.should == [
+      3
+      ]
+    interpreter = Bio::FinishM::ConnectionInterpreter.new(
+      conns, [1,2,4,5,6]
+      )
+    interpreter.unconnected_sequences.should == [
+      4,5,6
+      ]
+  end
+end

data/spec/contig_printer_spec.rb

@@ -0,0 +1,291 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ContigPrinter" do
+  describe 'sequences_to_variants_conservative' do
+    it 'should handle a multi-variant' do
+      seqs = [
+              'ATGAATATGTGCATAGGATT',
+              'ATGAATCGATGCAGTTGATT',
+              #      ###    ###
+              #01234567890123456789
+             ]
+      printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+      ref, variants = printer.send(:sequences_to_variants_conservative, seqs)
+
+      ref.should == 'ATGAATNNNTGCANNNGATT'
+      variants.collect{|v| v.to_shorthand
+      }.sort.should == [
+                   '7S:ATG',
+                   '7S:CGA',
+                   '14S:TAG',
+                   '14S:GTT',
+                  ].sort
+    end
+
+    it 'should handle a semi-redundant multi-variant' do
+      seqs = [
+              'ATGAATATGTGCATAGGATT',
+              'ATGAATCGATGCAGTTGATT',
+              'ATGAATCGATGCATAGGATT',
+              #      ###    ###
+              #01234567890123456789
+             ]
+      printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+      ref, variants = printer.send(:sequences_to_variants_conservative, seqs)
+
+      ref.should == 'ATGAATNNNTGCANNNGATT'
+      variants.collect{|v| v.to_shorthand
+      }.sort.should == [
+                   '7S:ATG',
+                   '7S:CGA',
+                   '14S:TAG',
+                   '14S:GTT',
+                  ].sort
+    end
+    
+    it 'should handle not variants' do
+      seqs = [
+              'ATGAATATGTGCATAGGATT',
+             ]
+      printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+      ref, variants = printer.send(:sequences_to_variants_conservative, seqs)
+
+      ref.should == 'ATGAATATGTGCATAGGATT'
+      variants.collect{|v| v.to_shorthand
+      }.sort.should == [].sort
+    end
+
+    it 'should handle gaps' do
+      seqs = [
+              'ATTCTGAACGTAAGCATTATATGAATATGTGCATAGGATTTATTGGATCAGTGGCACGTA',
+              'ATTCTGAACGTAAGCATTATATGAATATGTGCAGTTGATTTATTGGATCAGTGGCACGTA',
+              'ATTCTGAACGTAAGCATTATATGAATCGATGAGTT GATTTATTGGATCAGTGGCACGTA',
+              #                          ###  - !!!
+              #1234567890123456789012345678901234567890123456..........
+              #         1         2         3         4
+             ]
+      printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+      ref, variants = printer.send(:sequences_to_variants_conservative, seqs)
+
+      ref.should == 'ATTCTGAACGTAAGCATTATATGAATNNNTGNNNNNGATTTATTGGATCAGTGGCACGTA'
+      variants.collect{|v| v.to_shorthand
+      }.sort.should == [
+        '27S:ATG',
+        '27S:CGA',
+        '32S:CATAG',
+        '32S:CAGTT',
+        '32S:AGTT',
+        '36D:1',
+        ].sort
+    end
+  end
+
+
+
+  #     it 'should work with 3 variants' do
+  #       graph, paths = GraphTesting.emit_paths([
+  #         [1,2,3],
+  #         [1,4,3],
+  #         [1,5,3],
+  #         [1,6,3],
+  #         ])
+  #       printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+  #       conn = printer.two_contigs_and_connection_to_printable_connection(paths)
+  #       conn.comparable.should == GraphTesting.emit_printer_connection(graph,
+  #         [1,2,3], [
+  #           [1,3,4],
+  #           [1,3,5],
+  #           [1,3,6],
+  #           ])
+  #     end
+
+  #     it 'should work with a >1 node variant' do
+  #       graph, paths = GraphTesting.emit_paths([
+  #         [1,2,3],
+  #         [1,4,5,6,3],
+  #         ])
+  #       printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+  #       conn = printer.two_contigs_and_connection_to_printable_connection(paths)
+  #       conn.comparable.should == GraphTesting.emit_printer_connection(graph,
+  #         [1,2,3], [[1,3,4,5,6]]
+  #         )
+  #     end
+
+  #     it 'should work with 2 bubbles' do
+  #       graph, paths = GraphTesting.emit_paths([
+  #         [1,2,3,4,5],
+  #         [1,6,3,7,5],
+  #         ])
+  #       printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+  #       conn = printer.two_contigs_and_connection_to_printable_connection(paths)
+  #       conn.comparable.should == GraphTesting.emit_printer_connection(graph,
+  #         [1,2,3,4,5], [[1,3,6],[3,5,7]]
+  #         )
+  #     end
+
+  #     it 'should work with 2 overlapping bubbles' do
+  #       graph, paths = GraphTesting.emit_paths([
+  #         [1,2,3,4,5],
+  #         [1,6,3,7,5],
+  #         [1,2,3,7,5],
+  #         ])
+  #       printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
+  #       conn = printer.two_contigs_and_connection_to_printable_connection(paths)
+  #       conn.comparable.should == GraphTesting.emit_printer_connection(graph,
+  #         [1,2,3,4,5], [[1,3,6],[3,5,7]]
+  #         )
+  #     end
+  #   end
+
+  describe 'one_connection_between_two_contigs first' do
+    it 'should work with a path with two nodes both in the same direction' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      acon.start_probe_noded_read = graph.nodes[9].short_reads.select{|nr| nr.read_id == 161}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      acon.end_probe_noded_read = graph.nodes[4].short_reads.select{|nr| nr.read_id == 1045}[0]
+      acon.start_probe_contig_offset = 0
+      acon.end_probe_contig_offset = 0
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 11e 2s 10s 4e))
+        ]
+      expected = '12345'+
+        File.open(File.join TEST_DATA_DIR, 'contig_printer','1','seq2_1to550.fa').readlines[1].strip.gsub(/..$/,'') +
+        '67890'
+      observed = Bio::AssemblyGraphAlgorithms::ContigPrinter.new.one_connection_between_two_contigs(
+        graph,'12345',acon,'67890',[]
+        )
+      observed.should == expected
+    end
+
+    it 'should handle reads not starting right at the end of the contig' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      acon.start_probe_noded_read = graph.nodes[9].short_reads.select{|nr| nr.read_id == 161}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      acon.end_probe_noded_read = graph.nodes[4].short_reads.select{|nr| nr.read_id == 1045}[0]
+      acon.start_probe_contig_offset = 1
+      acon.end_probe_contig_offset = 2
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 11e 2s 10s 4e))
+        ]
+      expected = '1234'+
+        File.open(File.join TEST_DATA_DIR, 'contig_printer','1','seq2_1to550.fa').readlines[1].strip.gsub(/..$/,'') +
+        '890'
+      observed = Bio::AssemblyGraphAlgorithms::ContigPrinter.new.one_connection_between_two_contigs(
+        graph,'12345',acon,'67890',[]
+        )
+      observed.should == expected
+    end
+
+    it 'should reverse reads starting from reverse onodes to start the process' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      #  #<Bio::Velvet::Graph::NodedRead:0x0000000293fd08 @direction=false, @offset_from_start_of_node=2, @read_id=289, @start_coord=0>,
+      acon.start_probe_noded_read = graph.nodes[7].short_reads.select{|nr| nr.read_id == 289}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      acon.end_probe_noded_read = graph.nodes[4].short_reads.select{|nr| nr.read_id == 1045}[0]
+      acon.start_probe_contig_offset = 0
+      acon.end_probe_contig_offset = 0
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(7e 13s 5e 11e 2s 10s 4e))
+        ]
+      expected = '12345'+
+        'TAATACCGTATAATGACTTCGGTCCAAAGATTTATCGCCCAGGGATGAGCCCGCGTAGGATTAGCTTGTTGGTGAGGTAAAGGCTCACCAAGGCGACGATCCTTAGCTGGTCTGAGAGGATGATCAGCCACACTGGGACTGAGACATGGCCCAGACTCCTACGGGAGGCAGCAGTGGGGAATATTGGACAATGGGCGAAAGCCTGATCCAGCAATGCCGCGTGAGTGATGAAGGCCTTAGGGTTGTAAAGCTCTTTTACCCGGGATGATAATGACAGTACCGGGAGAATAAGCCCCGGCTAACTCCGTGCCAGCAGCCGCGGTAATACGGAGGGGGCTAGCGTTGTTCGGAATTACTGGGCGTAAAGCGCACGTAGGCGGCTTTGTAAGTTAGAGGTGAAAGCCCGGGGCTCAACTCCGGAATT' +
+        '67890'
+      observed = Bio::AssemblyGraphAlgorithms::ContigPrinter.new.one_connection_between_two_contigs(
+        graph,'12345',acon,'67890',[]
+        )
+      observed.should == expected
+    end
+
+    it 'should reverse reads starting from reverse onodes to start the process' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      #  #<Bio::Velvet::Graph::NodedRead:0x0000000293fd08 @direction=false, @offset_from_start_of_node=2, @read_id=289, @start_coord=0>,
+      acon.start_probe_noded_read = graph.nodes[7].short_reads.select{|nr| nr.read_id == 289}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      #  #<Bio::Velvet::Graph::NodedRead:0x00000002763ef8 @direction=false, @offset_from_start_of_node=3, @read_id=800, @start_coord=0>,
+      acon.end_probe_noded_read = graph.nodes[10].short_reads.select{|nr| nr.read_id == 800}[0]
+      acon.start_probe_contig_offset = 0
+      acon.end_probe_contig_offset = 0
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(7e 13s 5e 11e 2s 10s))
+        ]
+      expected = '12345'+
+        'TAATACCGTATAATGACTTCGGTCCAAAGATTTATCGCCCAGGGATGAGCCCGCGTAGGATTAGCTTGTTGGTGAGGTAAAGGCTCACCAAGGCGACGATCCTTAGCTGGTCTGAGAGGATGATCAGCCACACTGGGACTGAGACATGGCCCAGACTCCTACGGGAGGCAGCAG' +
+        '67890'
+      observed = Bio::AssemblyGraphAlgorithms::ContigPrinter.new.one_connection_between_two_contigs(
+        graph,'12345',acon,'67890',[]
+        )
+      observed.should == expected
+    end
+  end
+
+  describe 'ready_two_contigs_and_connections' do
+    it 'should handle a single SNP' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      acon.start_probe_noded_read = graph.nodes[9].short_reads.select{|nr| nr.read_id == 161}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      acon.end_probe_noded_read = graph.nodes[4].short_reads.select{|nr| nr.read_id == 1045}[0]
+      acon.start_probe_contig_offset = 2
+      acon.end_probe_contig_offset = 3
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 11e 2s 10s 4e)),#highest coverage
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 1e 2e 10s 4e)),
+        ]
+      expected = 
+        'ATGAACGAACGCTGGCGGCATGCCTAACACATGCAAGTCGAACGAGACCTTCGGGTCTAGTGGCGCACGGGTGCGTAACGCGTGGGAATCTGCCCTTGGGTACGG'+
+        'AATAACAGTTAGAAATGACTGCTAATACCGTATAATGACTTCGGTCCAAAGATTTATCGCCCAGGGATGAGCCCGCGTAGGATTAGCTTGTTGGTGAGGTAAANN'+
+        'NTNNCNNANNNNNNNNNNNNTNNNNNGNNNNNNNNNNNGNTNAGNNNCNNNGNNNNNGNGANNTGGCCCAGACTCCTACGGGAGGCAGCAGTGGGGAATATTGGACAATGGGC'+
+        'GAAAGCCTGATCCAGCAATGCCGCGTGAGTGATGAAGGCCTTAGGGTTGTAAAGCTCTTTTACCCGGGATGATAATGACAGTACCGGGAGAATAAGCCCCGGCTAACTCCGTG'+
+        'CCAGCAGCCGCGGTAATACGGAGGGGGCTAGCGTTGTTCGGAATTACTGGGCGTAAAGCGCACGTAGGCGGCTTTGTAAGTTAGAGGTGAAAGCCCGGGGCTCAACTCCGGAATTCA'
+      observed_sequence, observed_variants = Bio::AssemblyGraphAlgorithms::ContigPrinter.new.ready_two_contigs_and_connections(
+        graph,'ATGCA',acon,'ATGCA',[]
+        )
+      observed_sequence.should == expected
+      observed_variants.collect{|v|v.to_shorthand}.sort.should == [
+        "210S:GGC", "214S:CA", "217S:CA", "220S:GGCGACGATCCT", "233S:AGCTG", "239S:TCTGAGAGGAT", "251S:A", "253S:C", "256S:CCA", "260S:ACT", "264S:GGACT", "270S:A", "273S:CA",
+        "210S:TTT", "214S:AC", "217S:TC", "220S:CCAACAAGCTAA", "233S:CCTAC", "239S:CGCTCAGACCA", "251S:C", "253S:A", "256S:GAT", "260S:GTC", "264S:CCTTG", "270S:T", "273S:GC",
+        ].sort
+    end
+
+    it 'should handle when start_coord is not == 0 and both reads are inwards facing' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      acon.start_probe_noded_read = graph.nodes[9].short_reads.select{|nr| nr.read_id == 161}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      acon.end_probe_noded_read = graph.nodes[4].short_reads.select{|nr| nr.read_id == 1045}[0]
+      acon.start_probe_contig_offset = 0
+      acon.end_probe_contig_offset = 0
+
+      # introduce badness
+      acon.start_probe_noded_read.start_coord = 3
+      acon.end_probe_noded_read.start_coord = 4
+      reads = {
+        161 => 'A'*100,
+        1045 => 'C'*100,
+        }
+
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 11e 2s 10s 4e))
+        ]
+      expected = '12345'+'AAA'+
+        File.open(File.join TEST_DATA_DIR, 'contig_printer','1','seq2_1to550.fa').readlines[1].strip.gsub(/..$/,'') +
+        'CCCC'+'67890'
+      observed = Bio::AssemblyGraphAlgorithms::ContigPrinter.new.one_connection_between_two_contigs(
+        graph,'12345',acon,'67890', reads
+        )
+      observed.should == expected
+    end
+
+    it 'should handle when start_coord is not == 0 and both reads are outwards facing' do
+      raise
+    end
+    
+    it 'should handle when the example path is not the same length as the reference path' do
+      fail
+    end
+  end
+end