Changeset 888

Show
Ignore:
Timestamp:
05/04/07 13:11:10 (2 years ago)
Author:
sandal
Message:

I needed to clean this sucker up before I could work on it

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • ruport/trunk/test/renderer_test.rb

    r868 r888  
    22require 'ruport' 
    33 
    4  
    5 class TrivialRenderer < Ruport::Renderer 
     4########################################################################### 
     5# 
     6#  NOTE: 
     7# 
     8#  As it stands, we haven't found a more clever way to test the formatting 
     9#  system than to just create a bunch of renderers and basic formatters for 
     10#  different concepts we're trying to test.  Patches and ideas welcome: 
     11# 
     12#  list.rubyreports.org 
     13############################################################################ 
     14 
     15#============================================================================ 
     16# These two renderers represent the two styles that can be used when defining 
     17# renderers in Ruport.  The OldSchoolRenderer approach has largely been 
     18# deprecated, but still has uses in edge cases that we need to support. 
     19#============================================================================ 
     20 
     21class OldSchoolRenderer < Ruport::Renderer 
    622 
    723  def run 
    …… 
    1531end                
    1632 
    17 class YetAnotherRenderer < Ruport::Renderer 
     33class VanillaRenderer < Ruport::Renderer 
    1834  stage :header,:body,:footer 
    1935end 
    2036 
     37 
     38# This formatter implements some junk output so we can be sure 
     39# that the hooks are being set up right.  Perhaps these could 
     40# be replaced by mock objects in the future. 
    2141class DummyText < Ruport::Formatter 
    2242   
    23   renders :text, :for => TrivialRenderer 
     43  renders :text, :for => OldSchoolRenderer 
    2444   
    2545  def prepare_document 
    …… 
    4464end    
    4565 
     66 
     67# This formatter is meant to check out a special case in Ruport's renderer, 
     68# in which a layout method is called and yielded to when defined 
    4669class WithLayout < DummyText 
    47    renders :text_with_layout, :for => YetAnotherRenderer  
     70   renders :text_with_layout, :for => VanillaRenderer  
    4871    
    4972   def layout      
    …… 
    5578end 
    5679 
    57 class TrivialRenderer2 < TrivialRenderer; end 
    58  
     80 
     81# This provides a way to check the multi-format hooks for the Renderer 
    5982class MultiPurposeFormatter < Ruport::Formatter  
    6083 
    61    renders [:html,:text], :for => TrivialRenderer2 
     84   renders [:html,:text], :for => VanillaRenderer 
    6285 
    6386   def build_header 
    …… 
    7497   end 
    7598 
    76    def build_footer; end  
    7799end    
    78100 
    79 # FIXME: come up with a better name 
    80 class RendererWithHelpers < Ruport::Renderer 
     101# This provides a way to check several hooks that Renderer supports 
     102class RendererWithManyHooks < Ruport::Renderer 
    81103 
    82104  add_format DummyText, :text 
    …… 
    98120end 
    99121 
     122 
     123# This checks the evil AutoRunner edgecase 
    100124class RendererWithRunHook < Ruport::Renderer 
    101125   
    …… 
    115139end 
    116140 
    117 class RendererWithHelperModule < TrivialRenderer2 
    118  
    119   add_format DummyText, :stub 
    120  
    121   module Helpers 
    122     def say_hello 
    123       "Hello Dolly" 
    124     end 
    125   end 
    126 end    
    127  
    128 class ErbFormatter < Ruport::Formatter 
    129     
    130   renders :terb, :for  => TrivialRenderer2 
    131    
    132   def build_header; end #gross, refactor             
    133   def build_footer; end #gross, refactor  
    134   def build_body     
    135      # demonstrate local binding 
    136      @foo = "bar"                          
    137      if options.binding 
    138        output << erb("Binding Override: <%= reverse %>",  
    139                      :binding => options.binding)  
    140      else    
    141        output << erb("Default Binding: <%= @foo %>")  
    142      end    
    143   end 
    144    
    145 end 
    146  
    147 class TestFormatterErbHelper < Test::Unit::TestCase 
    148    def test_self_bound 
    149      assert_equal "Default Binding: bar", TrivialRenderer2.render_terb 
    150    end 
    151     
    152    def test_custom_bound 
    153      a = [1,2,3] 
    154      arr_binding = a.instance_eval { binding } 
    155      assert_equal "Binding Override: 321",  
    156                   TrivialRenderer2.render_terb(:binding => arr_binding) 
    157    end 
     141class TestRendererWithHelperModule < Test::Unit::TestCase 
     142 
     143  class RendererWithHelperModule < VanillaRenderer 
     144 
     145    add_format DummyText, :stub 
     146 
     147    module Helpers 
     148      def say_hello 
     149        "Hello Dolly" 
     150      end 
     151    end 
     152  end    
     153 
     154  def test_renderer_helper_module 
     155    RendererWithHelperModule.render_stub do |r| 
     156      assert_equal "Hello Dolly", r.formatter.say_hello 
     157    end 
     158  end 
    158159end 
    159160 
    …… 
    161162 
    162163  def test_multi_purpose 
    163     text = TrivialRenderer2.render_text(:body_text => "foo") 
     164    text = VanillaRenderer.render_text(:body_text => "foo") 
    164165    assert_equal "Foo: 10\nfoo", text 
    165     html = TrivialRenderer2.render_html(:body_text => "bar") 
     166    html = VanillaRenderer.render_html(:body_text => "bar") 
    166167    assert_equal "<b>Foo: 10</b>\n<pre>\nbar\n</pre>\n",html 
    167168  end 
    …… 
    194195 
    195196  def test_hash_options_setters 
    196     a = RendererWithHelpers.render(:text, :subtitle => "foo", 
     197    a = RendererWithManyHooks.render(:text, :subtitle => "foo", 
    197198                                       :subsubtitle => "bar") { |r| 
    198199      assert_equal "foo", r.options.subtitle 
    …… 
    202203 
    203204  def test_data_accessors 
    204    a = RendererWithHelpers.render(:text, :data => [1,2,4]) { |r| 
     205   a = RendererWithManyHooks.render(:text, :data => [1,2,4]) { |r| 
    205206     assert_equal [1,2,4], r.data 
    206207   } 
    207208   
    208    b = RendererWithHelpers.render_text(%w[a b c]) { |r| 
     209   b = RendererWithManyHooks.render_text(%w[a b c]) { |r| 
    209210     assert_equal %w[a b c], r.data 
    210211   } 
    211212   
    212    c = RendererWithHelpers.render_text(%w[a b f],:snapper => :red) { |r| 
     213   c = RendererWithManyHooks.render_text(%w[a b f],:snapper => :red) { |r| 
    213214     assert_equal %w[a b f], r.data 
    214215     assert_equal :red, r.options.snapper 
    …… 
    219220    require "stringio" 
    220221    out = StringIO.new 
    221     a = TrivialRenderer.render(:text) { |r| r.io = out } 
     222    a = OldSchoolRenderer.render(:text) { |r| r.io = out } 
    222223    out.rewind 
    223224    assert_equal "header\nbody\nfooter\n", out.read 
    …… 
    226227 
    227228  def test_trivial 
    228     actual = TrivialRenderer.render(:text) 
     229    actual = OldSchoolRenderer.render(:text) 
    229230    assert_equal "header\nbody\nfooter\n", actual 
    230231  end 
    …… 
    232233  def test_formats 
    233234    assert_equal( {}, Ruport::Renderer.formats ) 
    234     assert_equal( { :text => DummyText },TrivialRenderer.formats ) 
     235    assert_equal( { :text => DummyText },OldSchoolRenderer.formats ) 
    235236  end 
    236237 
    237238  def test_stage_helper 
    238     assert RendererWithHelpers.stages.include?('body') 
     239    assert RendererWithManyHooks.stages.include?('body') 
    239240  end 
    240241  
    241242  def test_finalize_helper 
    242     assert_equal :document, RendererWithHelpers.final_stage 
     243    assert_equal :document, RendererWithManyHooks.final_stage 
    243244  end 
    244245 
    245246  def test_prepare_helper 
    246    assert_equal :document, RendererWithHelpers.first_stage 
     247   assert_equal :document, RendererWithManyHooks.first_stage 
    247248  end 
    248249 
    249250  def test_finalize_again 
    250251   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) {  
    251      RendererWithHelpers.finalize :report  
     252     RendererWithManyHooks.finalize :report  
    252253   } 
    253254  end 
    …… 
    255256  def test_prepare_again 
    256257   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) {  
    257      RendererWithHelpers.prepare :foo  
     258     RendererWithManyHooks.prepare :foo  
    258259   } 
    259260  end 
    260261 
    261262  def test_renderer_using_helpers 
    262    actual = RendererWithHelpers.render(:text) 
     263   actual = RendererWithManyHooks.render(:text) 
    263264   assert_equal "pheader\nbody\nfooter\nf", actual 
    264265 
    265    actual = RendererWithHelpers.render_text 
     266   actual = RendererWithManyHooks.render_text 
    266267   assert_equal "pheader\nbody\nfooter\nf", actual 
    267268  end 
    …… 
    269270  def test_setup 
    270271   actual = false 
    271    RendererWithHelpers.render_text { |r| 
     272   RendererWithManyHooks.render_text { |r| 
    272273     actual = r.options.apple 
    273274   } 
    …… 
    276277 
    277278  def test_option_helper 
    278    RendererWithHelpers.render_text do |r| 
     279   RendererWithManyHooks.render_text do |r| 
    279280     r.subtitle = "Test Report" 
    280281     assert_equal "Test Report", r.options.subtitle 
    …… 
    283284 
    284285  def test_required_option_helper 
    285    a = RendererWithHelpers.dup 
     286   a = RendererWithManyHooks.dup 
    286287   a.required_option :title 
    287288 
    …… 
    294295 
    295296  def test_without_required_option 
    296  
    297    a = RendererWithHelpers.dup 
     297   a = RendererWithManyHooks.dup 
    298298   a.required_option :title 
    299299 
    …… 
    302302                                            
    303303  def test_method_missing 
    304     actual = TrivialRenderer.render_text 
     304    actual = OldSchoolRenderer.render_text 
    305305    assert_equal "header\nbody\nfooter\n", actual 
    306306  end 
    307307 
    308308  def test_formatter 
    309      #RendererWithHelpers.required_option :title 
    310   
    311      assert_raise(RuntimeError) { RendererWithHelpers.render(:text) } 
    312    end 
     309   assert_raise(RuntimeError) { RendererWithManyHooks.render(:text) } 
     310  end 
    313311 
    314312 
    315313  def test_method_missing 
    316     actual = TrivialRenderer.render_text 
     314    actual = OldSchoolRenderer.render_text 
    317315    assert_equal "header\nbody\nfooter\n", actual 
    318316  end 
    …… 
    321319    # normal instance mode 
    322320     
    323     rend = TrivialRenderer.new 
     321    rend = OldSchoolRenderer.new 
    324322    rend.send(:use_formatter,:text) 
    325323 
    …… 
    328326 
    329327    # render mode 
    330     TrivialRenderer.render_text do |r| 
     328    OldSchoolRenderer.render_text do |r| 
    331329      assert_kind_of Ruport::Formatter, r.formatter 
    332330      assert_kind_of DummyText, r.formatter 
    …… 
    362360  def test_layout 
    363361     assert_equal "---\nheader\nbody\nfooter\n---\n",  
    364                   YetAnotherRenderer.render_text_with_layout 
    365   end 
    366  
    367   def test_renderer_helper_module 
    368     RendererWithHelperModule.render_stub do |r| 
    369       assert_equal "Hello Dolly", r.formatter.say_hello 
    370     end 
    371   end 
    372  
    373  
    374  
    375 end 
     362                  VanillaRenderer.render_text_with_layout 
     363  end 
     364 
     365end 
     366 
     367class ErbFormatter < Ruport::Formatter 
     368    
     369  renders :terb, :for  => VanillaRenderer 
     370   
     371  def build_body     
     372     # demonstrate local binding 
     373     @foo = "bar"                          
     374     if options.binding 
     375       output << erb("Binding Override: <%= reverse %>",  
     376                     :binding => options.binding)  
     377     else    
     378       output << erb("Default Binding: <%= @foo %>")  
     379     end    
     380  end 
     381   
     382end 
     383 
     384class TestFormatterErbHelper < Test::Unit::TestCase 
     385   def test_self_bound 
     386     assert_equal "Default Binding: bar", VanillaRenderer.render_terb 
     387   end 
     388    
     389   def test_custom_bound 
     390     a = [1,2,3] 
     391     arr_binding = a.instance_eval { binding } 
     392     assert_equal "Binding Override: 321",  
     393                   VanillaRenderer.render_terb(:binding => arr_binding) 
     394   end 
     395end 
     396 
     397