ruport 1.6.3 → 1.8.0

data/test/controller_test.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -w   
+#!/usr/bin/env ruby -w
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 ###########################################################################
@@ -28,7 +28,7 @@ class OldSchoolController < Ruport::Controller
     end
   end
 
-end               
+end
 
 class VanillaController < Ruport::Controller
   stage :header,:body,:footer
@@ -39,9 +39,9 @@ end
 # 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 => OldSchoolController
-  
+
   def prepare_document
     output << "p"
   end
@@ -61,7 +61,7 @@ class DummyText < Ruport::Formatter
   def finalize_document
     output << "f"
   end
-end   
+end
 
 # This formatter modifies the (String) data object passed to it
 class Destructive < Ruport::Formatter
@@ -84,17 +84,17 @@ end
 class VanillaBinary < Ruport::Formatter
   renders :bin, :for => VanillaController
   save_as_binary_file
-end 
+end
 
 class SpecialFinalize < Ruport::Formatter
   renders :with_finalize, :for => VanillaController
-  
+
   def finalize
     output << "I has been finalized"
   end
 end
 
-class TestController < Test::Unit::TestCase
+class TestController < Minitest::Test
 
   def teardown
     Ruport::Formatter::Template.instance_variable_set(:@templates, nil)
@@ -103,60 +103,60 @@ class TestController < Test::Unit::TestCase
   def test_trivial
     actual = OldSchoolController.render(:text)
     assert_equal "header\nbody\nfooter\n", actual
-  end          
-  
+  end
+
   context "when running a formatter with custom a finalize method" do
-    def specify_finalize_method_should_be_called
-      assert_equal "I has been finalized", 
+    should "specify_finalize_method_should_be_called" do
+      assert_equal "I has been finalized",
                    VanillaController.render_with_finalize
-    end                
+    end
   end
-  
+
   context "when using templates" do
-    def specify_apply_template_should_be_called
+    should "specify_apply_template_should_be_called" do
       Ruport::Formatter::Template.create(:stub)
-      Table(%w[a b c]).to_csv(:template => :stub) do |r| 
+      Ruport.Table(%w[a b c]).to_csv(:template => :stub) do |r|
        r.formatter.expects(:apply_template)
-      end  
-    end 
+      end
+    end
 
-    def specify_undefined_template_should_throw_sensible_error
+    should "specify_undefined_template_should_throw_sensible_error" do
       assert_raises(Ruport::Formatter::TemplateNotDefined) do
-        Table(%w[a b c]).to_csv(:template => :sub)
-      end 
+        Ruport.Table(%w[a b c]).to_csv(:template => :sub)
+      end
     end
   end
 
   context "when using default templates" do
-    def specify_default_template_should_be_called
+    should "specify_default_template_should_be_called" do
       Ruport::Formatter::Template.create(:default)
-      Table(%w[a b c]).to_csv do |r| 
+      Ruport.Table(%w[a b c]).to_csv do |r|
         r.formatter.expects(:apply_template)
         assert r.formatter.template == Ruport::Formatter::Template[:default]
-      end  
+      end
     end
 
-    def specify_specific_should_override_default
+    should "specify_specific_should_override_default" do
       Ruport::Formatter::Template.create(:default)
       Ruport::Formatter::Template.create(:stub)
-      Table(%w[a b c]).to_csv(:template => :stub) do |r| 
+      Ruport.Table(%w[a b c]).to_csv(:template => :stub) do |r|
         r.formatter.expects(:apply_template)
         assert r.formatter.template == Ruport::Formatter::Template[:stub]
-      end  
+      end
     end
 
-    def specify_should_be_able_to_disable_templates
+    should "specify_should_be_able_to_disable_templates" do
       Ruport::Formatter::Template.create(:default)
-      Table(%w[a b c]).to_csv(:template => false) do |r| 
+      Ruport.Table(%w[a b c]).to_csv(:template => false) do |r|
         r.formatter.expects(:apply_template).never
-      end  
+      end
     end
   end
 
   def test_using_io
     require "stringio"
     out = StringIO.new
-    a = OldSchoolController.render(:text) { |r| r.io = out }
+    OldSchoolController.render(:text) { |r| r.io = out }
     out.rewind
     assert_equal "header\nbody\nfooter\n", out.read
     assert_equal "", out.read
@@ -165,21 +165,21 @@ class TestController < Test::Unit::TestCase
   def test_using_file
     f = []
     File.expects(:open).yields(f)
-    a = OldSchoolController.render(:text, :file => "foo.text")
+    OldSchoolController.render(:text, :file => "foo.text")
     assert_equal "header\nbody\nfooter\n", f[0]
-    
+
     f = []
     File.expects(:open).with("blah","wb").yields(f)
-    VanillaController.render(:bin, :file => "blah")        
-  end       
-  
-  def test_using_file_via_rendering_tools     
+    VanillaController.render(:bin, :file => "blah")
+  end
+
+  def test_using_file_via_rendering_tools
     f = []
-    File.expects(:open).yields(f)  
-    Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).save_as("foo.csv")      
-    assert_equal "a,b,c\n1,2,3\n4,5,6\n", f[0]  
+    File.expects(:open).yields(f)
+    Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).save_as("foo.csv")
+    assert_equal "a,b,c\n1,2,3\n4,5,6\n", f[0]
   end
-    
+
 
   def test_formats
     assert_equal( {}, Ruport::Controller.formats )
@@ -209,33 +209,33 @@ class TestController < Test::Unit::TestCase
 
     rend.formatter.clear_output
     assert_equal "", rend.formatter.output
-  end  
-  
+  end
+
   def test_options_act_like_indifferent_hash
      opts = Ruport::Controller::Options.new
      opts.foo = "bar"
      assert_equal "bar", opts[:foo]
-     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
+
 end
 
 
-class TestFormatterUsingBuild < Test::Unit::TestCase
+class TestFormatterUsingBuild < Minitest::Test
   # This formatter uses the build syntax
   class UsesBuild < Ruport::Formatter
-     renders :text_using_build, :for => VanillaController 
-     
+     renders :text_using_build, :for => VanillaController
+
      build :header do
        output << "header\n"
      end
@@ -246,7 +246,7 @@ class TestFormatterUsingBuild < Test::Unit::TestCase
 
      build :footer do
        output << "footer\n"
-     end     
+     end
   end
 
   def test_should_render_using_build_syntax
@@ -261,25 +261,25 @@ class TestFormatterUsingBuild < Test::Unit::TestCase
 end
 
 
-class TestFormatterWithLayout < Test::Unit::TestCase
+class TestFormatterWithLayout < Minitest::Test
   # 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 => VanillaController 
-     
-     def layout     
+     renders :text_with_layout, :for => VanillaController
+
+     def layout
        output << "---\n"
        yield
        output << "---\n"
      end
-     
+
   end
 
   def test_layout
-     assert_equal "---\nheader\nbody\nfooter\n---\n", 
+     assert_equal "---\nheader\nbody\nfooter\n---\n",
                   VanillaController.render_text_with_layout
   end
-  
+
   def test_layout_disabled
      assert_equal "header\nbody\nfooter\n",
                   VanillaController.render_text_with_layout(:layout => false)
@@ -288,7 +288,7 @@ class TestFormatterWithLayout < Test::Unit::TestCase
 end
 
 
-class TestControllerWithManyHooks < Test::Unit::TestCase
+class TestControllerWithManyHooks < Minitest::Test
   # This provides a way to check several hooks that controllers supports
   class ControllerWithManyHooks < Ruport::Controller
     add_format DummyText, :text
@@ -305,30 +305,28 @@ class TestControllerWithManyHooks < Test::Unit::TestCase
     def setup
       options.apple = true
     end
-
   end
 
   def test_hash_options_setters
-    a = ControllerWithManyHooks.render(:text, :subtitle => "foo",
-                                       :subsubtitle => "bar") { |r|
+    ControllerWithManyHooks.render(:text, :subtitle => "foo", :subsubtitle => "bar") do |r|
       assert_equal "foo", r.options.subtitle
       assert_equal "bar", r.options.subsubtitle
-    }
+    end
   end
 
   def test_data_accessors
-   a = ControllerWithManyHooks.render(:text, :data => [1,2,4]) { |r|
-     assert_equal [1,2,4], r.data
-   }
-  
-   b = ControllerWithManyHooks.render_text(%w[a b c]) { |r|
-     assert_equal %w[a b c], r.data
-   }
-  
-   c = ControllerWithManyHooks.render_text(%w[a b f],:snapper => :red) { |r|
-     assert_equal %w[a b f], r.data
-     assert_equal :red, r.options.snapper
-   }
+    ControllerWithManyHooks.render(:text, :data => [1,2,4]) do |r|
+      assert_equal [1,2,4], r.data
+    end
+
+    ControllerWithManyHooks.render_text(%w[a b c]) do |r|
+      assert_equal %w[a b c], r.data
+    end
+
+    ControllerWithManyHooks.render_text(%w[a b f],:snapper => :red) do |r|
+      assert_equal %w[a b f], r.data
+      assert_equal :red, r.options.snapper
+    end
   end
 
   def test_formatter_data_dup
@@ -341,7 +339,7 @@ class TestControllerWithManyHooks < Test::Unit::TestCase
   def test_stage_helper
     assert ControllerWithManyHooks.stages.include?('body')
   end
- 
+
   def test_finalize_helper
     assert_equal :document, ControllerWithManyHooks.final_stage
   end
@@ -351,14 +349,14 @@ class TestControllerWithManyHooks < Test::Unit::TestCase
   end
 
   def test_finalize_again
-   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
-     ControllerWithManyHooks.finalize :report 
+   assert_raises(Ruport::Controller::StageAlreadyDefinedError) {
+     ControllerWithManyHooks.finalize :report
    }
   end
 
   def test_prepare_again
-   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
-     ControllerWithManyHooks.prepare :foo 
+   assert_raises(Ruport::Controller::StageAlreadyDefinedError) {
+     ControllerWithManyHooks.prepare :foo
    }
   end
 
@@ -385,13 +383,13 @@ class TestControllerWithManyHooks < Test::Unit::TestCase
    a = ControllerWithManyHooks.dup
    a.required_option :title
 
-   assert_raise(Ruport::Controller::RequiredOptionNotSet) { a.render(:text) }
+   assert_raises(Ruport::Controller::RequiredOptionNotSet) { a.render(:text) }
   end
- 
+
 end
 
 
-class TestControllerWithRunHook < Test::Unit::TestCase
+class TestControllerWithRunHook < Minitest::Test
 
   class ControllerWithRunHook < Ruport::Controller
     add_format DummyText, :text
@@ -409,14 +407,14 @@ class TestControllerWithRunHook < Test::Unit::TestCase
   end
 
   def test_renderer_with_run_hooks
-    assert_equal "|header\nbody\nfooter\n", 
+    assert_equal "|header\nbody\nfooter\n",
        ControllerWithRunHook.render_text(:foo => "bar",:bar => "baz")
   end
 
 end
 
 
-class TestControllerWithHelperModule < Test::Unit::TestCase
+class TestControllerWithHelperModule < Minitest::Test
 
   class ControllerWithHelperModule < VanillaController
 
@@ -427,7 +425,7 @@ class TestControllerWithHelperModule < Test::Unit::TestCase
         "Hello Dolly"
       end
     end
-  end   
+  end
 
   def test_renderer_helper_module
     ControllerWithHelperModule.render_stub do |r|
@@ -437,9 +435,9 @@ class TestControllerWithHelperModule < Test::Unit::TestCase
 end
 
 
-class TestMultiPurposeFormatter < Test::Unit::TestCase
+class TestMultiPurposeFormatter < Minitest::Test
   # This provides a way to check the multi-format hooks for the Controller
-  class MultiPurposeFormatter < Ruport::Formatter 
+  class MultiPurposeFormatter < Ruport::Formatter
 
      renders [:html,:text], :for => VanillaController
 
@@ -447,7 +445,7 @@ class TestMultiPurposeFormatter < Test::Unit::TestCase
        a = 10
 
        text { output << "Foo: #{a}\n" }
-       html { output << "<b>Foo: #{a}</b>\n" } 
+       html { output << "<b>Foo: #{a}</b>\n" }
      end
 
      def build_body
@@ -456,7 +454,7 @@ class TestMultiPurposeFormatter < Test::Unit::TestCase
        html { output << "\n</pre>\n" }
      end
 
-  end   
+  end
 
   def test_multi_purpose
     text = VanillaController.render_text(:body_text => "foo")
@@ -471,12 +469,12 @@ class TestMultiPurposeFormatter < Test::Unit::TestCase
 
     a = MultiPurposeFormatter.new
     a.format = :html
-    
+
     visited = false
     a.html { visited = true }
 
     assert visited
-    
+
     visited = false
     a.text { visited = true }
     assert !visited
@@ -489,100 +487,100 @@ class TestMultiPurposeFormatter < Test::Unit::TestCase
 end
 
 
-class TestFormatterErbHelper < Test::Unit::TestCase
+class TestFormatterErbHelper < Minitest::Test
   class ErbFormatter < Ruport::Formatter
-     
+
     renders :terb, :for  => VanillaController
-    
-    def build_body    
+
+    def build_body
        # demonstrate local binding
-       @foo = "bar"                         
+       @foo = "bar"
        if options.binding
-         output << erb("Binding Override: <%= reverse %>", 
-                       :binding => options.binding) 
-       else   
-         output << erb("Default Binding: <%= @foo %>") 
-       end   
+         output << erb("Binding Override: <%= reverse.inspect %>",
+                       :binding => options.binding)
+       else
+         output << erb("Default Binding: <%= @foo %>")
+       end
     end
-    
+
   end
 
-   #FIXME: need to test file
+  #FIXME: need to test file
 
    def test_self_bound
      assert_equal "Default Binding: bar", VanillaController.render_terb
    end
-   
+
    def test_custom_bound
      a = [1,2,3]
      arr_binding = a.instance_eval { binding }
-     assert_equal "Binding Override: 321", 
+     assert_equal "Binding Override: [3, 2, 1]",
                    VanillaController.render_terb(:binding => arr_binding)
    end
-end    
+end
+
 
+class TestOptionReaders < Minitest::Test
 
-class TestOptionReaders < Test::Unit::TestCase
-  
   class ControllerForCheckingOptionReaders < Ruport::Controller
-    required_option :foo  
-  end 
-  
+    required_option :foo
+  end
+
   class ControllerForCheckingPassivity < Ruport::Controller
     def foo
       "apples"
     end
-    required_option :foo    
+    required_option :foo
   end
 
-   def setup 
-     @renderer = ControllerForCheckingOptionReaders.new 
-     @renderer.formatter = Ruport::Formatter.new 
-     
+   def setup
+     @renderer = ControllerForCheckingOptionReaders.new
+     @renderer.formatter = Ruport::Formatter.new
+
      @passive = ControllerForCheckingPassivity.new
      @passive.formatter = Ruport::Formatter.new
    end
-   
+
    def test_options_are_readable
       @renderer.foo = 5
       assert_equal 5, @renderer.foo
-   end                                   
-   
+   end
+
    def test_methods_are_not_overridden
      @passive.foo = 5
      assert_equal "apples", @passive.foo
      assert_equal 5, @passive.options.foo
      assert_equal 5, @passive.formatter.options.foo
    end
-     
+
 end
-     
-class TestSetupOrdering < Test::Unit::TestCase
-   
+
+class TestSetupOrdering < Minitest::Test
+
   class ControllerWithSetup < Ruport::Controller
     stage :bar
     def setup
       options.foo.capitalize!
-    end        
-  end           
-  
-  class BasicFormatter < Ruport::Formatter 
+    end
+  end
+
+  class BasicFormatter < Ruport::Formatter
     renders :text, :for => ControllerWithSetup
-    
+
     def build_bar
       output << options.foo
     end
   end
-  
+
   def test_render_hash_options_should_be_called_before_setup
     assert_equal "Hello", ControllerWithSetup.render_text(:foo => "hello")
-  end       
-  
+  end
+
   def test_render_block_should_be_called_before_setup
-    assert_equal "Hello", 
+    assert_equal "Hello",
       ControllerWithSetup.render_text { |r| r.options.foo = "hello" }
   end
-  
+
 end
 
 class CustomFormatter < Ruport::Formatter
@@ -608,7 +606,7 @@ class ControllerWithAnonymousFormatters < Ruport::Controller
   end
 
   formatter :pdf do
-    build :report do 
+    build :report do
       add_text "hello world"
     end
   end
@@ -630,24 +628,20 @@ class ControllerWithAnonymousFormatters < Ruport::Controller
 
 end
 
-class TestAnonymousFormatter < Test::Unit::TestCase
-  context "When using built in Ruport formatters" do
+class TestAnonymousFormatter < Minitest::Test
 
-    def specify_text_formatter_shortcut_is_accessible
-      assert_equal "Hello world", ControllerWithAnonymousFormatters.render_text
-      assert_equal "1,2,3\n", ControllerWithAnonymousFormatters.render_csv
-      assert_equal "<h1>Hi there</h1>", ControllerWithAnonymousFormatters.render_html
+  def test_text_formatter_shortcut_is_accessible
+    assert_equal "Hello world", ControllerWithAnonymousFormatters.render_text
+    assert_equal "1,2,3\n", ControllerWithAnonymousFormatters.render_csv
+    assert_equal "<h1>Hi there</h1>", ControllerWithAnonymousFormatters.render_html
+    if RUBY_VERSION < "1.9"
       assert_not_nil ControllerWithAnonymousFormatters.render_pdf
     end
-    
   end
 
-  context "When using custom formatters" do
-    def specify_custom_formatter_shortcut_is_accessible
-      assert_equal "This is Custom!", ControllerWithAnonymousFormatters.render_custom
-    end
+  def test_custom_formatter_shortcut_is_accessible
+    assert_equal "This is Custom!", ControllerWithAnonymousFormatters.render_custom
   end
-
 end
 
 # Used to ensure that problems in controller code aren't mistakenly intercepted
@@ -663,106 +657,88 @@ class MisbehavingFormatter < Ruport::Formatter
   end
 end
 
-class TestMisbehavingController < Test::Unit::TestCase
+class TestMisbehavingController < Minitest::Test
 
-  context "using a controller that throws NoMethodError" do
-    def specify_controller_errors_should_bubble_up
-      assert_raises(NoMethodError) do
-        MisbehavingController.render :text
-      end
+  def test_controller_errors_should_bubble_up
+    assert_raises(NoMethodError) do
+      MisbehavingController.render :text
     end
   end
 
 end
 
-class TestControllerHooks < Test::Unit::TestCase
-
-  context "when renderable_data omitted" do
-
-    require "mocha"
+class TestControllerHooks < Minitest::Test
 
-    class DummyObject 
-      include Ruport::Controller::Hooks
-      renders_as_table
-    end
-
-    def specify_should_return_self
-      a = DummyObject.new
-      rend = mock("renderer")
-      rend.expects(:data=).with(a)
-      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
-      a.as(:csv)
-    end
+  require "mocha"
 
+  class DummyObject
+    include Ruport::Controller::Hooks
+    renders_as_table
   end
 
-  context "when using renderable_data" do
-
-    class DummyObject2
-      include Ruport::Controller::Hooks
-      renders_as_table
-
-      def renderable_data(format)
-        1
-      end
-    end
-
-    def specify_should_return_results_of_renderable_data
-      a = DummyObject2.new
-      rend = mock("renderer")
-      rend.expects(:data=).with(1)
-      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
-      a.as(:csv)
-    end
+  def test_should_return_self
+    a = DummyObject.new
+    rend = mock("renderer")
+    rend.expects(:data=).with(a)
+    Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+    a.as(:csv)
+  end
 
-    class DummyObject3
-      include Ruport::Controller::Hooks
-      renders_as_table
-      
-      def renderable_data
-        raise ArgumentError
-      end
-    end
+  class DummyObject2
+    include Ruport::Controller::Hooks
+    renders_as_table
 
-    def specify_should_not_mask_errors
-      assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
+    def renderable_data(_format)
+      1
     end
+  end
 
-    class DummyObject4
-      include Ruport::Controller::Hooks
-      renders_as_table
+  def test_should_return_results_of_renderable_data
+    a = DummyObject2.new
+    rend = mock("renderer")
+    rend.expects(:data=).with(1)
+    Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+    a.as(:csv)
+  end
 
-      def renderable_data(format)
-        case format
-        when :html
-          1
-        when :csv
-          2
-        end
-      end
-    end
+  class DummyObject3
+    include Ruport::Controller::Hooks
+    renders_as_table
 
-    def specify_should_return_results_of_renderable_data_using_format
-      a = DummyObject4.new
-      rend = mock("renderer")
-      rend.expects(:data=).with(2)
-      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
-      a.as(:csv)
+    def renderable_data
+      raise ArgumentError
     end
+  end
 
-  end    
-
-  context "when attempting to render a format that doesn't exist" do
+  def test_should_not_mask_errors
+    assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
+  end
 
-    def specify_an_unknown_format_error_should_be_raised
+  class DummyObject4
+    include Ruport::Controller::Hooks
+    renders_as_table
 
-      assert_raises(Ruport::Controller::UnknownFormatError) do
-        Ruport::Controller.render_foo
+    def renderable_data(format)
+      case format
+      when :html
+        1
+      when :csv
+        2
       end
-
     end
   end
 
+  def test_should_return_results_of_renderable_data_using_format
+    a = DummyObject4.new
+    rend = mock("renderer")
+    rend.expects(:data=).with(2)
+    Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+    a.as(:csv)
+  end
 
-
+  def test_an_unknown_format_error_should_be_raised
+    assert_raises(Ruport::Controller::UnknownFormatError) do
+      Ruport::Controller.render_foo
+    end
+  end
 end