ruport 0.8.14 → 0.10.0

data/test/pdf_formatter_test.rb

@@ -0,0 +1,25 @@
+require "test/unit"
+require "ruport"
+
+begin
+  require "rubygems"
+rescue LoadError
+  nil
+end
+
+class TestFormatPDF < Test::Unit::TestCase
+
+  def test_render_pdf_basic
+    begin
+      quiet { require "pdf/writer" } 
+    rescue LoadError 
+      warn "skipping pdf test"; return
+    end
+    data = [[1,2],[3,4]].to_table
+    assert_raise(RuntimeError) { data.to_pdf }
+
+    data.column_names = %w[a b]
+    assert_nothing_raised { data.to_pdf }
+  end
+
+end

data/test/{test_query.rb → query_test.rb}

@@ -22,8 +22,8 @@
        :alternative => {
          :dsn => "ruport:test2", :user => "sandal", :password => "harmonix" },
      }
-     Ruport::Config.source :default,     @sources[:default]
-     Ruport::Config.source :alternative, @sources[:alternative]
+     Ruport::Query.add_source :default,     @sources[:default]
+     Ruport::Query.add_source :alternative, @sources[:alternative]
  
      @columns = %w(a b c)
      @data = [ [[1,2,3],[4,5,6],[7,8,9]],
@@ -38,22 +38,17 @@
       :plain      => Ruport::Query.new(@sql[0]),
       :sourced    => Ruport::Query.new(@sql[0], :source        => :alternative),
       :paramed    => Ruport::Query.new(@sql[0], :params        => [ 42 ]),
-      :cached     => Ruport::Query.new(@sql[0], :cache_enabled => true),
-      :uncached   => Ruport::Query.new(@sql[0], :cache_enabled => false),
-      :precached  => Ruport::Query.new(@sql[0], :cache_enabled => true),
-      :raw        => Ruport::Query.new(@sql[0], :raw_data      => true),
-      :unraw      => Ruport::Query.new(@sql[0], :raw_data      => false),
+      :raw        => Ruport::Query.new(@sql[0], :row_type      => :raw),
       :resultless => Ruport::Query.new(@sql[1]),
       :multi      => Ruport::Query.new(@sql[2]),
       :mixed      => Ruport::Query.new(@sql[3]),
      }
-     @query[:precached].cached_data = @data[0]
    end
 
    if Object.const_defined? :Mocha and Object.const_defined? :DBI
  
      def test_execute
-       query = @query[:uncached]
+       query = @query[:plain]
        setup_mock_dbi(1)
  
        assert_equal nil, query.execute
@@ -74,26 +69,6 @@
        assert_equal nil, query.execute
      end
    
-     def test_result_cache_disabled
-       query = @query[:uncached]
-       setup_mock_dbi(3)
-       
-       assert_nothing_raised { query.result }
-       assert_equal @data[1], get_raw(query.result)
-       assert_equal @data[2], get_raw(query.result)
-
-     end
-     
-     def test_result_cache_enabled
-       query = @query[:cached]
-
-       setup_mock_dbi(1)
-       
-       assert_nothing_raised { query.result }
-       assert_equal @data[0], get_raw(query.result)
-       assert_equal @data[0], get_raw(query.result)
-     end
-   
      def test_result_resultless
        query = @query[:resultless]
        setup_mock_dbi(1, :resultless => true, :sql => @sql[1])
@@ -108,13 +83,6 @@
        assert_equal @data[1], get_raw(query.result)
      end
    
-     def test_result_raw_disabled
-       query = @query[:unraw]
-       setup_mock_dbi(1)
-       
-       assert_equal @data[0].to_table(@columns), query.result
-     end  
-   
      def test_result_raw_enabled
        query = @query[:raw]
        setup_mock_dbi(1)
@@ -122,49 +90,6 @@
        assert_equal @data[0], query.result
      end  
    
-     def test_update_cache
-       query = @query[:cached]
-       setup_mock_dbi(2)
-       
-       assert_equal @data[0], get_raw(query.result)
-       query.update_cache
-       assert_equal @data[1], get_raw(query.cached_data)
-       assert_equal @data[1], get_raw(query.result)
-     end
-   
-     def test_clear_cache
-       query = @query[:cached]
-       setup_mock_dbi(2)
-        
-       assert_equal @data[0], get_raw(query.result)
-
-       query.clear_cache
-       assert_equal nil,      query.cached_data
-       assert_equal @data[1], get_raw(query.result)
-     end
-     
-     def test_disable_caching
-       query = @query[:cached]
-       setup_mock_dbi(3)
-   
-       assert_equal @data[0], get_raw(query.result)
-       assert_equal @data[0], get_raw(query.result)
-       query.disable_caching
-       assert_equal @data[1], get_raw(query.result)
-       assert_equal @data[2], get_raw(query.result)    
-     end
-   
-     def test_enable_caching
-       query = @query[:uncached]
-       setup_mock_dbi(3)
-   
-       assert_equal @data[0], get_raw(query.result)
-       assert_equal @data[1], get_raw(query.result)
-       query.enable_caching
-       assert_equal @data[2], get_raw(query.result)
-       assert_equal @data[2], get_raw(query.result)    
-     end
-   
      def test_load_file
        File.expects(:read).
          with("query_test.sql").
@@ -174,32 +99,18 @@
        assert_equal "select * from foo", query.sql
      end
    
-     def test_load_file_erb
-       @table = 'bar'
-       File.expects(:read).
-         with("query_test.sql").
-         returns("select * from <%= @table %>\n")
-       
-       query = Ruport::Query.new "query_test.sql", :binding => binding
-       assert_equal "select * from bar", query.sql
-     end
-   
      def test_load_file_not_found
        File.expects(:read).
          with("query_test.sql").
          raises(Errno::ENOENT)
-       Ruport.expects(:log).
-         with("Could not open query_test.sql",
-              :status => :fatal, :exception => LoadError).
-         raises(LoadError)
    
        assert_raises LoadError do
          query = Ruport::Query.new "query_test.sql"
        end
      end
    
-     def test_each_cache_disabled
-       query = @query[:uncached]
+     def test_each
+       query = @query[:plain]
        setup_mock_dbi(2)
    
        result = []; query.each { |r| result << r.to_a }
@@ -208,18 +119,7 @@
        result = []; query.each { |r| result << r.to_a }
        assert_equal @data[1], result
      end  
-     
-     def test_each_cache_enabled
-       query = @query[:cached]
-       setup_mock_dbi(1)
-       
-       result = []; query.each { |r| result << r.to_a }
-       assert_equal @data[0], result
-                    
-       result = []; query.each { |r| result << r.to_a }
-       assert_equal @data[0], result
-     end  
-   
+
      def test_each_multi
        query = @query[:multi]
        setup_mock_dbi(2)
@@ -231,13 +131,11 @@
    end
    
    def test_each_without_block
-     assert_raise (LocalJumpError) { @query[:precached].each }
+     assert_raise (LocalJumpError) { @query[:plain].each }
    end
    
    def test_select_source
-     query = @query[:precached]
-     assert_equal @sources[:default], get_query_source(query)
- 
+     query = @query[:plain]
      query.select_source :alternative
      assert_equal @sources[:alternative], get_query_source(query)
    
@@ -258,15 +156,6 @@
      assert_equal @sources[:alternative], get_query_source(query2)
    end
  
-   def test_generator
-     query = @query[:precached]
-     gen = query.generator
-     assert_equal @data[0][0], gen.next 
-     assert_equal @data[0][1], gen.next 
-     assert_equal @data[0][2], gen.next 
-     assert_raise(EOFError) { gen.next }
-   end
-
    if Object.const_defined? :Mocha and Object.const_defined? :DBI
  
      def test_to_table
@@ -285,6 +174,29 @@
        csv = @data[0].to_table(@columns).as(:csv)
        assert_equal csv, query.to_csv
      end
+     
+     def test_missing_dsn
+       assert_raise(ArgumentError) {
+         Ruport::Query.add_source :foo, :user => "root", :password => "fff"
+       }
+       assert_nothing_raised { Ruport::Query.add_source :bar, :dsn => "..." }
+     end
+
+     def test_new_defaults
+       Ruport::Query.add_source :default, :dsn      => "dbi:mysql:test",
+                                          :user     => "root",
+                                          :password => ""
+       assert_equal("dbi:mysql:test", Ruport::Query.default_source.dsn)
+       assert_equal("root", Ruport::Query.default_source.user)
+       assert_equal("", Ruport::Query.default_source.password)
+     end
+
+     def test_multiple_sources
+       Ruport::Query.add_source :foo, :dsn => "dbi:mysql:test"
+       Ruport::Query.add_source :bar, :dsn => "dbi:mysql:test2"
+       assert_equal("dbi:mysql:test",  Ruport::Query.sources[:foo].dsn)
+       assert_equal("dbi:mysql:test2", Ruport::Query.sources[:bar].dsn)
+     end
 
    end
      
@@ -330,5 +242,4 @@
    def get_raw(table)
      table.map { |row| row.to_a }
    end
-
 end

data/test/{test_record.rb → record_test.rb}

@@ -94,9 +94,9 @@ class TestRecord < Test::Unit::TestCase
     assert_equal [1,2,3,4], @record.to_a
   end
 
-  def test_to_h
-    assert_nothing_raised { @record.to_h }
-    assert_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 }, @record.to_h)
+  def test_to_hash
+    assert_nothing_raised { @record.to_hash }
+    assert_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 }, @record.to_hash)
   end  
   
   def test_rename_attribute
@@ -172,13 +172,9 @@ class TestRecord < Test::Unit::TestCase
     rec2["b"] = 7
     rec2[2] = 9
 
-    rec2.tag(:apple)
 
     assert_equal [1,2,3,4], rec1.to_a
     assert_equal [5,7,9,4], rec2.to_a
-
-    assert_equal Set.new([]), rec1.tags
-    assert_equal Set.new([:apple]), rec2.tags
   end
 
   def test_records_with_same_attrs_and_data_hash_the_same
@@ -201,7 +197,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal 3,r.length
     assert_equal 3,r.size
   end
-  
+
   def test_reindex
     assert_equal %w[a b c d], @record.attributes
     #old_object_id = @record.instance_variable_get(:@attributes).object_id
@@ -211,7 +207,28 @@ class TestRecord < Test::Unit::TestCase
 
     new_object_id = @record.instance_variable_get(:@attributes).object_id
     assert_equal a.object_id, new_object_id
-  end       
+  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
@@ -231,15 +248,6 @@ class TestRecord < Test::Unit::TestCase
     assert_equal 1, a["a"]
   end
 
-  def test_ensure_tags_get_duped
-    a = Record.new([1,2,3])
-    a.tag :foo
-    assert a.tags.include?(:foo)
-    b = a.dup
-    assert b.tags.include?(:foo)
-    assert_not_same a.tags, b.tags
-  end             
-  
   # Ticket #172
   def test_ensure_get_really_indifferent   
     a = Record.new({"a" => 1, "b" => 2})
@@ -250,12 +258,14 @@ class TestRecord < Test::Unit::TestCase
     assert_equal(2,a.get(:b))
   end
 
-  def test_ensure_get_works_ordinally
+  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_nothing_raised { a.get(0) }
-    b = Record.new({"a" => 1, "b" => 2},:attributes => %w[a b])
-    assert_equal 2, a.get(1)
-    assert_equal 1, a.get(0)
+    assert_raises(ArgumentError) { a.get([]) }
   end
   
   def test_ensure_delete_removes_attribute
@@ -282,4 +292,11 @@ class TestRecord < Test::Unit::TestCase
     assert_equal(["a","b","c"], a.attributes)
   end
 
+  class MyRecordSub < Ruport::Data::Record; end
+
+  def test_ensure_record_subclasses_render_properly
+    a = MyRecordSub.new [1,2,3]
+    assert_equal "1,2,3\n", a.to_csv
+  end
+
 end

data/test/renderer_test.rb

@@ -0,0 +1,344 @@
+require 'test/unit'
+require 'ruport'
+
+
+class TrivialRenderer < Ruport::Renderer
+
+  def run
+    formatter do
+      build_header
+      build_body
+      build_footer
+    end
+  end
+
+end               
+
+class YetAnotherRenderer < Ruport::Renderer
+  stage :header,:body,:footer
+end
+
+class DummyText < Ruport::Formatter
+  
+  renders :text, :for => TrivialRenderer
+  
+  def prepare_document
+    output << "p"
+  end
+
+  def build_header
+    output << "header\n"
+  end
+
+  def build_body
+    output << "body\n"
+  end
+
+  def build_footer
+    output << "footer\n"
+  end
+
+  def finalize_document
+    output << "f"
+  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
+
+  stage :header
+  stage :body
+  stage :footer
+
+  finalize :document
+
+  def setup
+    options.apple = true
+  end
+
+end
+
+class RendererWithRunHook < Ruport::Renderer
+  
+  include AutoRunner
+
+  add_format DummyText, :text
+
+  required_option :foo,:bar
+  stage :header
+  stage :body
+  stage :footer
+
+  def run
+    formatter.output << "|"
+  end
+
+end
+
+class RendererWithHelperModule < TrivialRenderer2
+
+  add_format DummyText, :stub
+
+  module Helpers
+    def say_hello
+      "Hello Dolly"
+    end
+  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
+
+
+  def test_renderer_with_run_hooks
+    assert_equal "|header\nbody\nfooter\n", 
+       RendererWithRunHook.render_text(:foo => "bar",:bar => "baz")
+  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
+
+  def test_hash_options_setters
+    a = RendererWithHelpers.render(:text, :subtitle => "foo",
+                                       :subsubtitle => "bar") { |r|
+      assert_equal "foo", r.options.subtitle
+      assert_equal "bar", r.options.subsubtitle
+    }
+  end
+
+  def test_data_accessors
+   a = RendererWithHelpers.render(:text, :data => [1,2,4]) { |r|
+     assert_equal [1,2,4], r.data
+   }
+  
+   b = RendererWithHelpers.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|
+     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')
+  end
+ 
+  def test_finalize_helper
+    assert_equal :document, RendererWithHelpers.final_stage
+  end
+
+  def test_prepare_helper
+   assert_equal :document, RendererWithHelpers.first_stage
+  end
+
+  def test_finalize_again
+   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
+     RendererWithHelpers.finalize :report 
+   }
+  end
+
+  def test_prepare_again
+   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
+     RendererWithHelpers.prepare :foo 
+   }
+  end
+
+  def test_renderer_using_helpers
+   actual = RendererWithHelpers.render(:text)
+   assert_equal "pheader\nbody\nfooter\nf", actual
+
+   actual = RendererWithHelpers.render_text
+   assert_equal "pheader\nbody\nfooter\nf", actual
+  end
+
+  def test_setup
+   actual = false
+   RendererWithHelpers.render_text { |r|
+     actual = r.options.apple
+   }
+   assert actual
+  end
+
+  def test_option_helper
+   RendererWithHelpers.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.required_option :title
+
+   a.render_text do |r|
+     r.title = "Test Report"
+     assert_equal "Test Report", r.options.title
+   end
+
+  end
+
+  def test_without_required_option
+
+   a = RendererWithHelpers.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
+
+
+  def test_method_missing
+    actual = TrivialRenderer.render_text
+    assert_equal "header\nbody\nfooter\n", actual
+  end
+
+  def test_formatter
+    # normal instance mode
+    
+    rend = TrivialRenderer.new
+    rend.send(:use_formatter,:text)
+
+    assert_kind_of Ruport::Formatter, rend.formatter
+    assert_kind_of DummyText, rend.formatter
+
+    # render mode
+    TrivialRenderer.render_text do |r|
+      assert_kind_of Ruport::Formatter, r.formatter
+      assert_kind_of DummyText, r.formatter
+    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     
+  
+  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
+  end
+
+  def test_renderer_helper_module
+    RendererWithHelperModule.render_stub do |r|
+      assert_equal "Hello Dolly", r.formatter.say_hello
+    end
+  end
+
+
+
+end