ruport 0.11.0 → 0.12.0

data/test/html_formatter_test.rb

@@ -1,13 +1,7 @@
 require "test/unit"
 require "ruport"
 
-begin
-  require "rubygems"
-rescue LoadError
-  nil
-end
-
-class TestFormatHTML < Test::Unit::TestCase
+class TestRenderHTMLTable < Test::Unit::TestCase
   
   def test_html_table
     a = Ruport::Formatter::HTML.new
@@ -37,13 +31,21 @@ class TestFormatHTML < Test::Unit::TestCase
       "\n\t\t\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
       "\t</tr>\n\t</table>",actual)   
     
-  end
+  end   
+end
+   
 
+class TestRenderHTMLRow < Test::Unit::TestCase
+  
   def test_render_html_row
     actual = Ruport::Renderer::Row.render_html { |r| r.data = [1,2,3] }
     assert_equal("\t\t<tr>\n\t\t\t<td>1</td>\n\t\t\t<td>2"+
                  "</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n",actual)
   end
+end
+   
+
+class TestRenderHTMLGroup < Test::Unit::TestCase
     
   def test_render_html_group
     group = Ruport::Data::Group.new(:name => 'test',
@@ -68,7 +70,11 @@ class TestFormatHTML < Test::Unit::TestCase
       "\n\t\t\t<td>2</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>"+
       "\n\t\t\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
       "\t</tr>\n\t</table>", actual
-  end
+  end                                           
+end
+
+
+class TestRenderHTMLGrouping < Test::Unit::TestCase
 
   def test_render_html_grouping
     table = Table(%w[a b c]) << [1,2,3] << [1,1,3] << [2,7,9]
@@ -95,6 +101,15 @@ class TestFormatHTML < Test::Unit::TestCase
                  "\t<th>c</th>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>7</td>\n"+
                  "\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>\n", actual
   end
+end  
+     
+
+class TestHTMLFormatterHelpers < Test::Unit::TestCase
+  begin
+    require "rubygems"
+  rescue LoadError
+    nil
+  end
   
   def test_textile     
     require "redcloth"
@@ -103,5 +118,4 @@ class TestFormatHTML < Test::Unit::TestCase
   rescue LoadError
     STDERR.puts "Skipping textile test... needs redcloth"
   end
-
 end

data/test/pdf_formatter_test.rb

@@ -9,17 +9,37 @@ end
 
 #require "pdf/writer"    
 
-class TestFormatPDF < Test::Unit::TestCase
+class TestRenderPDFTable < Test::Unit::TestCase
 
-  def test_render_pdf_basic
+  def test_render_pdf_basic  
+    # can't render without column names
     data = [[1,2],[3,4]].to_table
-    assert_raise(Ruport::FormatterError) { 
+    assert_raise(Ruport::FormatterError) do
       data.to_pdf 
-    }
+    end      
 
     data.column_names = %w[a b]
     assert_nothing_raised { data.to_pdf }
+    
+    assert_nothing_raised { Table(%w[a b c]).to_pdf }
+  end     
+                              
+  # this is mostly to check that the transaction hack gets called
+  def test_relatively_large_pdf
+     table = Table("test/samples/dates.csv")  
+     table.reduce(0..99)
+     assert_nothing_raised { table.to_pdf }
   end 
+     
+  # this is just to make sure that the column_opts code is being called.
+  # FIXME: add mocks to be sure
+  def test_table_with_options
+    data = [[1,2],[3,4]].to_table(%w[a b])
+    assert_nothing_raised do
+      data.to_pdf(:table_format => { 
+            :column_options => { :justification => :center } } ) 
+    end
+  end
   
   #--------BUG TRAPS--------#
   
@@ -28,7 +48,13 @@ class TestFormatPDF < Test::Unit::TestCase
   def test_tables_should_render_with_symbol_column_name
     data = [[1,2,3],[4,5,6]].to_table([:a,:b,:c])
     assert_nothing_raised { data.to_pdf }
-  end                                    
+  end  
+  
+end    
+
+class TestRenderPDFGrouping < Test::Unit::TestCase                                  
+   
+  #--------BUG TRAPS----------#
   
   # As of Ruport 0.10.0, PDF's justified group output was throwing
   # UnknownFormatError  (#288)
@@ -39,10 +65,78 @@ class TestFormatPDF < Test::Unit::TestCase
      assert_nothing_raised { grouping.to_pdf(:style => :inline) }
      assert_nothing_raised { grouping.to_pdf(:style => :offset) }     
      assert_nothing_raised { grouping.to_pdf(:style => :justified) }
-     assert_nothing_raised { grouping.to_pdf(:style => :separated) }    
+     assert_nothing_raised { grouping.to_pdf(:style => :separated) }
+     assert_raises(NotImplementedError) do 
+       grouping.to_pdf(:style => :red_snapper) 
+     end       
   end
   
+end
+
+class TestPDFFormatterHelpers < Test::Unit::TestCase   
   
+  def test_boundaries
+     a = Ruport::Formatter::PDF.new
+     
+     assert_equal 36, a.left_boundary    
+     a.pdf_writer.left_margin = 50 
+     assert_equal 50, a.left_boundary   
+     
+     assert_equal 576, a.right_boundary
+     a.pdf_writer.right_margin -= 10  
+     assert_equal 586, a.right_boundary 
+     
+     assert_equal 756, a.top_boundary
+     a.pdf_writer.top_margin -= 10
+     assert_equal 766, a.top_boundary
+     
+     assert_equal 36, a.bottom_boundary
+     a.pdf_writer.bottom_margin -= 10
+     assert_equal 26, a.bottom_boundary             
+  end
+     
+  def test_move_cursor
+     a = Ruport::Formatter::PDF.new
+     a.move_cursor_to(500)
+     assert_equal(500,a.cursor)  
+     a.move_cursor(-25)
+     assert_equal(475,a.cursor)
+     a.move_cursor(50)
+     assert_equal(525,a.cursor)
+  end           
   
-
-end
+  def test_padding
+    a = Ruport::Formatter::PDF.new
+    a.move_cursor_to(100)             
+    
+    # padding on top and bottom
+    a.pad(10) do        
+      assert_equal 90, a.cursor
+      a.move_cursor(-10)      
+      assert_equal 80, a.cursor
+    end
+    assert_equal(70,a.cursor)  
+    
+    a.move_cursor_to(100)
+    
+    # padding just on top  
+    a.pad_top(10) do
+      assert_equal 90, a.cursor
+      a.move_cursor(-10)
+      assert_equal 80, a.cursor
+    end
+    
+    assert_equal 80, a.cursor   
+    
+    a.move_cursor_to(100)  
+    
+    # padding just on bottom
+    a.pad_bottom(10) do
+      assert_equal 100, a.cursor
+      a.move_cursor(-10)
+      assert_equal 90, a.cursor
+    end  
+    
+    assert_equal 80, a.cursor        
+  end
+end

data/test/query_test.rb

@@ -53,7 +53,6 @@
  
        assert_equal nil, query.execute
      end
-
    
      def test_execute_sourced
        query = @query[:sourced]

data/test/record_test.rb

@@ -1,15 +1,17 @@
 require "test/unit"
 require "ruport"
-
-
-class TestRecord < Test::Unit::TestCase
-
-  include Ruport::Data
-
+                      
+module RecordTestSetup
   def setup
     @attributes = %w[a b c d]
     @record = Ruport::Data::Record.new [1,2,3,4], :attributes => @attributes 
   end
+end
+
+class TestRecord < Test::Unit::TestCase
+
+  include Ruport::Data
+  include RecordTestSetup 
 
   def test_init
     record = Ruport::Data::Record.new [1,2,3,4]
@@ -208,27 +210,6 @@ class TestRecord < Test::Unit::TestCase
     new_object_id = @record.instance_variable_get(:@attributes).object_id
     assert_equal a.object_id, new_object_id
   end
-
-  def test_record_as
-    rendered_row = @record.as(:text)
-    assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)
-  end
-
-  def test_to_hack
-    rendered_row = @record.to_text
-    assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)  
-    
-    rendered_row = @record.to_csv(:format_options => { :col_sep => "\t"})
-    assert_equal("1\t2\t3\t4\n",rendered_row)
-  end             
-
-  def test_as_throws_proper_errors
-    a = Record.new({ "a" => 1, "b" => 2 })
-    assert_nothing_raised { a.as(:csv) }
-    assert_nothing_raised { a.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { a.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { a.to_nothing }
-  end
   
   #----------------------------------------------------------------------
   #  BUG Traps
@@ -257,12 +238,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal(2,a.get("b"))
     assert_equal(2,a.get(:b))
   end
-
-  def test_ensure_attributes_not_broken_by_to_hack
-    record = Ruport::Data::Record.new [1,2], :attributes => %w[a to_something]
-    assert_equal 2, record.to_something
-  end
-
+  
   def test_ensure_get_throws_argument_error
     a = Record.new({"a" => 1, "b" => 2})
     assert_raises(ArgumentError) { a.get([]) }
@@ -298,5 +274,41 @@ class TestRecord < Test::Unit::TestCase
     a = MyRecordSub.new [1,2,3]
     assert_equal "1,2,3\n", a.to_csv
   end
+    
+end 
+    
+
+class TestRecordRenderering < Test::Unit::TestCase
+  
+  include RecordTestSetup
+  include Ruport::Data
+
+  def test_record_as
+    rendered_row = @record.as(:text)
+    assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)
+  end
+
+  def test_to_hack
+    rendered_row = @record.to_text
+    assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)  
+    
+    rendered_row = @record.to_csv(:format_options => { :col_sep => "\t"})
+    assert_equal("1\t2\t3\t4\n",rendered_row)
+  end             
+
+  def test_as_throws_proper_errors
+    a = Record.new({ "a" => 1, "b" => 2 })
+    assert_nothing_raised { a.as(:csv) }
+    assert_nothing_raised { a.to_csv }
+    assert_raises(Ruport::Renderer::UnknownFormatError) { a.as(:nothing) }
+    assert_raises(Ruport::Renderer::UnknownFormatError) { a.to_nothing }
+  end  
+  
+  ## -- BUG TRAPS --------------------
+  
+  def test_ensure_attributes_not_broken_by_to_hack
+    record = Ruport::Data::Record.new [1,2], :attributes => %w[a to_something]
+    assert_equal 2, record.to_something
+  end
 
 end

data/test/renderer_test.rb

@@ -1,8 +1,24 @@
 require 'test/unit'
 require 'ruport'
 
-
-class TrivialRenderer < Ruport::Renderer
+###########################################################################
+#
+#  NOTE:
+#
+#  As it stands, we haven't found a more clever way to test the formatting
+#  system than to just create a bunch of renderers and basic formatters for
+#  different concepts we're trying to test.  Patches and ideas welcome:
+#
+#  list.rubyreports.org
+############################################################################
+
+#============================================================================
+# These two renderers represent the two styles that can be used when defining
+# renderers in Ruport.  The OldSchoolRenderer approach has largely been
+# deprecated, but still has uses in edge cases that we need to support.
+#============================================================================
+
+class OldSchoolRenderer < Ruport::Renderer
 
   def run
     formatter do
@@ -14,13 +30,17 @@ class TrivialRenderer < Ruport::Renderer
 
 end               
 
-class YetAnotherRenderer < Ruport::Renderer
+class VanillaRenderer < Ruport::Renderer
   stage :header,:body,:footer
 end
 
+
+# This formatter implements some junk output so we can be sure
+# that the hooks are being set up right.  Perhaps these could
+# be replaced by mock objects in the future.
 class DummyText < Ruport::Formatter
   
-  renders :text, :for => TrivialRenderer
+  renders :text, :for => OldSchoolRenderer
   
   def prepare_document
     output << "p"
@@ -43,157 +63,119 @@ class DummyText < Ruport::Formatter
   end
 end   
 
-class WithLayout < DummyText
-   renders :text_with_layout, :for => YetAnotherRenderer 
-   
-   def layout     
-     output << "---\n"
-     yield
-     output << "---\n"
-   end
-   
-end
-
-class TrivialRenderer2 < TrivialRenderer; end
-
-class MultiPurposeFormatter < Ruport::Formatter 
-
-   renders [:html,:text], :for => TrivialRenderer2
-
-   def build_header
-     a = 10
-
-     text { output << "Foo: #{a}\n" }
-     html { output << "<b>Foo: #{a}</b>\n" } 
-   end
-
-   def build_body
-     html { output << "<pre>\n" }
-     output << options.body_text
-     html { output << "\n</pre>\n" }
-   end
-
-   def build_footer; end 
-end   
-
-# FIXME: come up with a better name
-class RendererWithHelpers < Ruport::Renderer
-
-  add_format DummyText, :text
-
-  prepare :document
 
-  option :subtitle, :subsubtitle
+class TestRenderer < Test::Unit::TestCase
 
-  stage :header
-  stage :body
-  stage :footer
+  def test_trivial
+    actual = OldSchoolRenderer.render(:text)
+    assert_equal "header\nbody\nfooter\n", actual
+  end
 
-  finalize :document
+  def test_using_io
+    require "stringio"
+    out = StringIO.new
+    a = OldSchoolRenderer.render(:text) { |r| r.io = out }
+    out.rewind
+    assert_equal "header\nbody\nfooter\n", out.read
+    assert_equal "", out.read
+  end
 
-  def setup
-    options.apple = true
+  def test_formats
+    assert_equal( {}, Ruport::Renderer.formats )
+    assert_equal( { :text => DummyText },OldSchoolRenderer.formats )
   end
 
-end
+  def test_method_missing
+    actual = OldSchoolRenderer.render_text
+    assert_equal "header\nbody\nfooter\n", actual
+  end
 
-class RendererWithRunHook < Ruport::Renderer
-  
-  include AutoRunner
+  def test_formatter
+    # normal instance mode
+    rend = OldSchoolRenderer.new
+    rend.send(:use_formatter,:text)
 
-  add_format DummyText, :text
+    assert_kind_of Ruport::Formatter, rend.formatter
+    assert_kind_of DummyText, rend.formatter
 
-  required_option :foo,:bar
-  stage :header
-  stage :body
-  stage :footer
+    # render mode
+    OldSchoolRenderer.render_text do |r|
+      assert_kind_of Ruport::Formatter, r.formatter
+      assert_kind_of DummyText, r.formatter
+    end
 
-  def run
-    formatter.output << "|"
-  end
+    assert_equal "body\n", rend.formatter { build_body }.output
 
+    rend.formatter.clear_output
+    assert_equal "", rend.formatter.output
+  end  
+  
+  def test_options_act_like_indifferent_hash
+     opts = Ruport::Renderer::Options.new
+     opts.foo = "bar"
+     assert_equal "bar", opts[:foo]
+     assert_equal "bar", opts["foo"]    
+     
+     opts["f"] = "bar"
+     assert_equal "bar", opts[:f]
+     assert_equal "bar", opts.f
+     assert_equal "bar", opts["f"]
+     
+     opts[:apple] = "banana"
+     assert_equal "banana", opts.apple
+     assert_equal "banana", opts["apple"]
+     assert_equal "banana", opts[:apple]
+  end     
+  
 end
 
-class RendererWithHelperModule < TrivialRenderer2
 
-  add_format DummyText, :stub
-
-  module Helpers
-    def say_hello
-      "Hello Dolly"
-    end
+class TestFormatterWithLayout < Test::Unit::TestCase
+  # This formatter is meant to check out a special case in Ruport's renderer,
+  # in which a layout method is called and yielded to when defined
+  class WithLayout < DummyText
+     renders :text_with_layout, :for => VanillaRenderer 
+     
+     def layout     
+       output << "---\n"
+       yield
+       output << "---\n"
+     end
+     
   end
-end   
 
-class ErbFormatter < Ruport::Formatter
-   
-  renders :terb, :for  => TrivialRenderer2
-  
-  def build_header; end #gross, refactor            
-  def build_footer; end #gross, refactor 
-  def build_body    
-     # demonstrate local binding
-     @foo = "bar"                         
-     if options.binding
-       output << erb("Binding Override: <%= reverse %>", 
-                     :binding => options.binding) 
-     else   
-       output << erb("Default Binding: <%= @foo %>") 
-     end   
+  def test_layout
+     assert_equal "---\nheader\nbody\nfooter\n---\n", 
+                  VanillaRenderer.render_text_with_layout
   end
-  
-end
 
-class TestFormatterErbHelper < Test::Unit::TestCase
-   def test_self_bound
-     assert_equal "Default Binding: bar", TrivialRenderer2.render_terb
-   end
-   
-   def test_custom_bound
-     a = [1,2,3]
-     arr_binding = a.instance_eval { binding }
-     assert_equal "Binding Override: 321", 
-                  TrivialRenderer2.render_terb(:binding => arr_binding)
-   end
 end
 
-class TestRenderer < Test::Unit::TestCase
 
-  def test_multi_purpose
-    text = TrivialRenderer2.render_text(:body_text => "foo")
-    assert_equal "Foo: 10\nfoo", text
-    html = TrivialRenderer2.render_html(:body_text => "bar")
-    assert_equal "<b>Foo: 10</b>\n<pre>\nbar\n</pre>\n",html
-  end
+class TestRendererWithManyHooks < Test::Unit::TestCase
+  # This provides a way to check several hooks that Renderer supports
+  class RendererWithManyHooks < Ruport::Renderer
 
+    add_format DummyText, :text
 
-  def test_renderer_with_run_hooks
-    assert_equal "|header\nbody\nfooter\n", 
-       RendererWithRunHook.render_text(:foo => "bar",:bar => "baz")
-  end
+    prepare :document
 
-  def test_method_missing_hack_formatter
-    assert_equal [:html,:text], MultiPurposeFormatter.formats
+    option :subtitle, :subsubtitle
 
-    a = MultiPurposeFormatter.new
-    a.format = :html
-    
-    visited = false
-    a.html { visited = true }
+    stage :header
+    stage :body
+    stage :footer
 
-    assert visited
-    
-    visited = false
-    a.text { visited = true }
-    assert !visited
+    finalize :document
 
-    assert_raises(NoMethodError) do
-      a.pdf { 'do nothing' }
+    def setup
+      options.apple = true
     end
+
   end
 
   def test_hash_options_setters
-    a = RendererWithHelpers.render(:text, :subtitle => "foo",
+    a = RendererWithManyHooks.render(:text, :subtitle => "foo",
                                        :subsubtitle => "bar") { |r|
       assert_equal "foo", r.options.subtitle
       assert_equal "bar", r.options.subsubtitle
@@ -201,88 +183,69 @@ class TestRenderer < Test::Unit::TestCase
   end
 
   def test_data_accessors
-   a = RendererWithHelpers.render(:text, :data => [1,2,4]) { |r|
+   a = RendererWithManyHooks.render(:text, :data => [1,2,4]) { |r|
      assert_equal [1,2,4], r.data
    }
   
-   b = RendererWithHelpers.render_text(%w[a b c]) { |r|
+   b = RendererWithManyHooks.render_text(%w[a b c]) { |r|
      assert_equal %w[a b c], r.data
    }
   
-   c = RendererWithHelpers.render_text(%w[a b f],:snapper => :red) { |r|
+   c = RendererWithManyHooks.render_text(%w[a b f],:snapper => :red) { |r|
      assert_equal %w[a b f], r.data
      assert_equal :red, r.options.snapper
    }
   end
 
-  def test_using_io
-    require "stringio"
-    out = StringIO.new
-    a = TrivialRenderer.render(:text) { |r| r.io = out }
-    out.rewind
-    assert_equal "header\nbody\nfooter\n", out.read
-    assert_equal "", out.read
-  end
-
-  def test_trivial
-    actual = TrivialRenderer.render(:text)
-    assert_equal "header\nbody\nfooter\n", actual
-  end
-
-  def test_formats
-    assert_equal( {}, Ruport::Renderer.formats )
-    assert_equal( { :text => DummyText },TrivialRenderer.formats )
-  end
-
   def test_stage_helper
-    assert RendererWithHelpers.stages.include?('body')
+    assert RendererWithManyHooks.stages.include?('body')
   end
  
   def test_finalize_helper
-    assert_equal :document, RendererWithHelpers.final_stage
+    assert_equal :document, RendererWithManyHooks.final_stage
   end
 
   def test_prepare_helper
-   assert_equal :document, RendererWithHelpers.first_stage
+   assert_equal :document, RendererWithManyHooks.first_stage
   end
 
   def test_finalize_again
    assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
-     RendererWithHelpers.finalize :report 
+     RendererWithManyHooks.finalize :report 
    }
   end
 
   def test_prepare_again
    assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
-     RendererWithHelpers.prepare :foo 
+     RendererWithManyHooks.prepare :foo 
    }
   end
 
   def test_renderer_using_helpers
-   actual = RendererWithHelpers.render(:text)
+   actual = RendererWithManyHooks.render(:text)
    assert_equal "pheader\nbody\nfooter\nf", actual
 
-   actual = RendererWithHelpers.render_text
+   actual = RendererWithManyHooks.render_text
    assert_equal "pheader\nbody\nfooter\nf", actual
   end
 
   def test_setup
    actual = false
-   RendererWithHelpers.render_text { |r|
+   RendererWithManyHooks.render_text { |r|
      actual = r.options.apple
    }
    assert actual
   end
 
   def test_option_helper
-   RendererWithHelpers.render_text do |r|
+   RendererWithManyHooks.render_text do |r|
      r.subtitle = "Test Report"
      assert_equal "Test Report", r.options.subtitle
    end
   end
 
   def test_required_option_helper
-   a = RendererWithHelpers.dup
+   a = RendererWithManyHooks.dup
    a.required_option :title
 
    a.render_text do |r|
@@ -293,83 +256,145 @@ class TestRenderer < Test::Unit::TestCase
   end
 
   def test_without_required_option
-
-   a = RendererWithHelpers.dup
+   a = RendererWithManyHooks.dup
    a.required_option :title
 
    assert_raise(Ruport::Renderer::RequiredOptionNotSet) { a.render(:text) }
   end
-                                           
-  def test_method_missing
-    actual = TrivialRenderer.render_text
-    assert_equal "header\nbody\nfooter\n", actual
-  end
-
-  def test_formatter
-     #RendererWithHelpers.required_option :title
  
-     assert_raise(RuntimeError) { RendererWithHelpers.render(:text) }
-   end
+end
 
 
-  def test_method_missing
-    actual = TrivialRenderer.render_text
-    assert_equal "header\nbody\nfooter\n", actual
-  end
+class TestRendererWithRunHook < Test::Unit::TestCase
 
-  def test_formatter
-    # normal instance mode
+  class RendererWithRunHook < Ruport::Renderer
     
-    rend = TrivialRenderer.new
-    rend.send(:use_formatter,:text)
+    include AutoRunner
 
-    assert_kind_of Ruport::Formatter, rend.formatter
-    assert_kind_of DummyText, rend.formatter
+    add_format DummyText, :text
 
-    # render mode
-    TrivialRenderer.render_text do |r|
-      assert_kind_of Ruport::Formatter, r.formatter
-      assert_kind_of DummyText, r.formatter
+    required_option :foo,:bar
+    stage :header
+    stage :body
+    stage :footer
+
+    def run
+      formatter.output << "|"
     end
 
-    assert_equal "body\n", rend.formatter { build_body }.output
+  end
 
-    rend.formatter.clear_output
-    assert_equal "", rend.formatter.output
-  end  
-  
-  def test_options_act_like_indifferent_hash
-     opts = Ruport::Renderer::Options.new
-     opts.foo = "bar"
-     assert_equal "bar", opts[:foo]
-     assert_equal "bar", opts["foo"]    
-     
-     opts["f"] = "bar"
-     assert_equal "bar", opts[:f]
-     assert_equal "bar", opts.f
-     assert_equal "bar", opts["f"]
-     
-     opts[:apple] = "banana"
-     assert_equal "banana", opts.apple
-     assert_equal "banana", opts["apple"]
-     assert_equal "banana", opts[:apple]
-  end     
-  
-  def test_add_format_private
-     assert_raise(NoMethodError) { Ruport::Renderer.add_format }
-  end 
-  
-  def test_layout
-     assert_equal "---\nheader\nbody\nfooter\n---\n", 
-                  YetAnotherRenderer.render_text_with_layout
+  def test_renderer_with_run_hooks
+    assert_equal "|header\nbody\nfooter\n", 
+       RendererWithRunHook.render_text(:foo => "bar",:bar => "baz")
   end
 
+end
+
+
+class TestRendererWithHelperModule < Test::Unit::TestCase
+
+  class RendererWithHelperModule < VanillaRenderer
+
+    add_format DummyText, :stub
+
+    module Helpers
+      def say_hello
+        "Hello Dolly"
+      end
+    end
+  end   
+
   def test_renderer_helper_module
     RendererWithHelperModule.render_stub do |r|
       assert_equal "Hello Dolly", r.formatter.say_hello
     end
   end
+end
+
+
+class TestMultiPurposeFormatter < Test::Unit::TestCase
+  # This provides a way to check the multi-format hooks for the Renderer
+  class MultiPurposeFormatter < Ruport::Formatter 
+
+     renders [:html,:text], :for => VanillaRenderer
+
+     def build_header
+       a = 10
+
+       text { output << "Foo: #{a}\n" }
+       html { output << "<b>Foo: #{a}</b>\n" } 
+     end
+
+     def build_body
+       html { output << "<pre>\n" }
+       output << options.body_text
+       html { output << "\n</pre>\n" }
+     end
+
+  end   
+
+  def test_multi_purpose
+    text = VanillaRenderer.render_text(:body_text => "foo")
+    assert_equal "Foo: 10\nfoo", text
+    html = VanillaRenderer.render_html(:body_text => "bar")
+    assert_equal "<b>Foo: 10</b>\n<pre>\nbar\n</pre>\n",html
+  end
+
+
+  def test_method_missing_hack_formatter
+    assert_equal [:html,:text], MultiPurposeFormatter.formats
+
+    a = MultiPurposeFormatter.new
+    a.format = :html
+    
+    visited = false
+    a.html { visited = true }
+
+    assert visited
+    
+    visited = false
+    a.text { visited = true }
+    assert !visited
+
+    assert_raises(NoMethodError) do
+      a.pdf { 'do nothing' }
+    end
+  end
 
+end
+
+
+class TestFormatterErbHelper < Test::Unit::TestCase
+  class ErbFormatter < Ruport::Formatter
+     
+    renders :terb, :for  => VanillaRenderer
+    
+    def build_body    
+       # demonstrate local binding
+       @foo = "bar"                         
+       if options.binding
+         output << erb("Binding Override: <%= reverse %>", 
+                       :binding => options.binding) 
+       else   
+         output << erb("Default Binding: <%= @foo %>") 
+       end   
+    end
+    
+  end
 
+   #FIXME: need to test file
 
+   def test_self_bound
+     assert_equal "Default Binding: bar", VanillaRenderer.render_terb
+   end
+   
+   def test_custom_bound
+     a = [1,2,3]
+     arr_binding = a.instance_eval { binding }
+     assert_equal "Binding Override: 321", 
+                   VanillaRenderer.render_terb(:binding => arr_binding)
+   end
 end
+
+