ruport 0.7.2 → 0.8.0

data/test/{test_text_table.rb → test_format_text.rb}

@@ -1,4 +1,6 @@
-class TextPluginTest < Test::Unit::TestCase
+require "test/unit"
+require "ruport"
+class TestFormatText < Test::Unit::TestCase
   
   def test_basic
 
@@ -21,7 +23,7 @@ class TextPluginTest < Test::Unit::TestCase
                   a.as(:text) { |e| e.layout.alignment = :center })
 
     tf = "+------------+\n"
-    a.column_names = %w[a bark]
+    a.column_names = %w[a bark]     
     assert_equal("#{tf}|  a  | bark |\n#{tf}|  1  |  2   |\n"+
                  "| 300 |  4   |\n#{tf}",
                   a.as(:text) { |e| e.layout.alignment = :center })

data/test/test_groupable.rb

@@ -9,34 +9,36 @@ end
 class TestGroupable < Test::Unit::TestCase
   def test_simple
     a = [[1,2],[3,4],[5,6],[7,8]].to_table(%w[a b])
-    a[0].tag(:foo); a[1].tag(:bar);
-    a[2].tag(:bar); a[3].tag(:foo);
+    a[0].tag("grp_foo"); a[1].tag("grp_bar");
+    a[2].tag("grp_bar"); a[3].tag("grp_foo");
 
 
     expected = Ruport::Data::Record.new( [ [[1,2],[7,8]].to_table(%w[a b]),
                                            [[3,4],[5,6]].to_table(%w[a b]) ], 
-                                           :attributes => ["foo","bar"] )
-    assert_equal expected, a.group_by_tag
+                                           :attributes => %w[foo bar] )
+    assert_equal expected, a.groups
 
-    a[0].tag(:bar)
+    a[0].tag("grp_bar")
 
     expected = Ruport::Data::Record.new( [ [[1,2],[7,8]].to_table(%w[a b]),
                                            [[1,2],[3,4],[5,6]].to_table(%w[a b]) ], 
                                            :attributes => ["foo","bar"] )
-    assert_equal expected, a.group_by_tag
+    assert_equal expected, a.groups
   end
 
-  def test_create_tag_group
+  def test_create_group
     a = [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]) 
     expected = Ruport::Data::Record.new( [ [[1,2,3],[7,8,9]].to_table(%w[a b c]),
                                           [[4,5,6]].to_table(%w[a b c]) ],
                                            :attributes => %w[starts_odd starts_even])
-    a.create_tag_group(:starts_odd) { |r| (r[0] % 2) != 0 }
-    a.create_tag_group(:starts_even) { |r| (r[0] % 2).zero? }
+    a.create_group("starts_odd") { |r| (r[0] % 2) != 0 }
+    a.create_group(:starts_even) { |r| (r[0] % 2).zero? }
 
-    assert_equal expected, a.group_by_tag
-  end
+    assert_equal expected, a.groups 
+    assert_equal([[1,2,3],[7,8,9]].to_table(%w[a b c]), a.group("starts_odd"))
+    assert_equal([[1,2,3],[7,8,9]].to_table(%w[a b c]), a.group(:starts_odd)) 
+    assert_equal([[4,5,6]].to_table(%w[a b c]), a.group("starts_even"))
+    
+  end  
 
 end
-
-

data/test/test_query.rb

@@ -77,11 +77,13 @@
      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
      return unless Object.const_defined? :Mocha
      query = @query[:cached]
+
      setup_mock_dbi(1)
      
      assert_nothing_raised { query.result }
@@ -136,8 +138,9 @@
      return unless Object.const_defined? :Mocha
      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)
@@ -303,7 +306,7 @@
      @dbh = mock("database_handle")
      @sth = mock("statement_handle")
      def @dbh.execute(*a, &b); execute__(*a, &b); ensure; sth__.finish if b; end
-     def @sth.each; data__.each { |x| yield(x) }; end
+     def @sth.each; data__.each { |x| yield(x.dup) }; end
      def @sth.fetch_all; data__; end
      
      DBI.expects(:connect).
@@ -332,7 +335,7 @@
    end
  
    def get_raw(table)
-     table.collect { |row| row.to_a }
+     table.map { |row| row.to_a }
    end
 
 end

data/test/test_record.rb

@@ -22,6 +22,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal 4, @record["d"]
     assert_equal 2, @record.b
     assert_equal 3, @record.c
+    assert_raise(NoMethodError) { @record.f }
   end
   
   def test_hash_constructor
@@ -29,6 +30,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal 1, record[:a]
     assert_equal 2, record[:b]
     assert_equal 3, record[:c]
+    assert_equal 3, record.c
   end
   
   def test_hash_constructor_with_attributes
@@ -36,6 +38,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal 1, record[:a]
     assert_equal 2, record[:b]
     assert_equal 3, record[:c]
+    assert_equal 3, record.c
     
     assert_equal 3, record[0]
     assert_equal 2, record[1]
@@ -52,6 +55,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal 2, @record["b"]
     assert_equal 3, @record["c"]
     assert_equal 4, @record["d"]
+    assert_equal 4, @record.d
   end
   
   def test_bracket_equals
@@ -93,7 +97,15 @@ class TestRecord < Test::Unit::TestCase
   def test_to_h
     assert_nothing_raised { @record.to_h }
     assert_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 }, @record.to_h)
-  end
+  end  
+  
+  def test_rename_attribute
+     @record.rename_attribute("b","x")
+     assert_equal %w[a x c d], @record.attributes
+     assert_equal 2, @record["x"]
+     assert_equal 2, @record.x
+     assert_equal 2, @record[1]
+  end   
 
   def test_equality
 
@@ -127,29 +139,29 @@ class TestRecord < Test::Unit::TestCase
   end
 
   def test_reordering
-    r = @record.reorder "a","d","b","c"
-    assert_equal [1,4,2,3], r.data
+    r = @record.dup.reorder "a","d","b","c"
+    assert_equal [1,4,2,3], r.to_a
     assert_equal %w[a d b c], r.attributes
 
-    assert_equal [1,2,3,4], @record.data
+    assert_equal [1,2,3,4], @record.to_a
     assert_equal %w[a b c d], @record.attributes
     
-    @record.reorder! "a","d","b","c"
-    assert_equal [1,4,2,3], @record.data
+    @record.reorder "a","d","b","c"
+    assert_equal [1,4,2,3], @record.to_a
     assert_equal %w[a d b c], @record.attributes
 
-    @record.reorder! 3,1,2
-    assert_equal [3,4,2], @record.data
+    @record.reorder 3,1,2
+    assert_equal [3,4,2], @record.to_a
     assert_equal %w[c d b], @record.attributes
 
-    r.reorder! %w[a b c]
-    assert_equal [1,2,3], r.data
+    r.reorder %w[a b c]
+    assert_equal [1,2,3], r.to_a
     assert_equal %w[a b c], r.attributes
 
-    assert_raise(ArgumentError) { r.reorder "foo" }
-    assert_raise(ArgumentError) { r.reorder 0,5 }
-    assert_nothing_raised { r.reorder 0 }
-    assert_nothing_raised { r.reorder "a","b" }
+    assert_raise(ArgumentError) { r.dup.reorder "foo" }
+    assert_raise(ArgumentError) { r.dup.reorder 0,5 }
+    assert_nothing_raised { r.dup.reorder 0 }
+    assert_nothing_raised { r.dup.reorder "a","b" }
   end
 
   def test_dup
@@ -162,11 +174,11 @@ class TestRecord < Test::Unit::TestCase
 
     rec2.tag(:apple)
 
-    assert_equal [1,2,3,4], rec1.data
-    assert_equal [5,7,9,4], rec2.data
+    assert_equal [1,2,3,4], rec1.to_a
+    assert_equal [5,7,9,4], rec2.to_a
 
-    assert_equal [], rec1.tags
-    assert_equal [:apple], rec2.tags
+    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
@@ -184,23 +196,35 @@ class TestRecord < Test::Unit::TestCase
     assert r.hash != t.hash
   end
 
-  # ticket:71
-  def test_record_has_indifferent_access
-    t = Record.new [1,2,3], :attributes => %w[a b c]
-    assert_equal [1,2,3], [t[0],t[1],t[2]]
-    assert_equal [1,2,3], [t["a"],t["b"],t["c"]]
-    assert_equal [1,2,3], [t.a,t.b,t.c]
+  def test_length_and_size
+    r = Record.new({:a => 1, :b => 2, :c => 3})
+    assert_equal 3,r.length
+    assert_equal 3,r.size
+  end
 
-    assert_equal [1,2,3], [t[:a],t[:b],t[:c]]
-    
-    t[:c] = 4
-    assert_equal [1,2,4], [t["a"],t["b"],t["c"]]
+  def test_ensure_records_dup_source_data
+    a = [1,2,3]
+    b = Record.new(a)
+    b[0] += 1
+    assert_equal 2, b[0]
+    assert_equal 1, a[0]
 
-    x = Record.new [1,2,3], :attributes => [:a,:b,:c]
-    assert_equal [1,2,3], [x[0],x[1],x[2]]
-    assert_equal [1,2,3], [x[:a],x[:b],x[:c]]
+    a = { "a" => 1, "b" => 2, "c" => 3 }
+    b = Record.new(a)
+    b["a"] += 1
+    assert_equal 2, b["a"]
+    assert_equal 1, a["a"]
+  end
 
-    assert_equal [1,2,3], [x["a"],x["b"],x["c"]]
-    assert_equal [1,2,3], [x.a,x.b,x.c]
+  def test_reindex
+    assert_equal %w[a b c d], @record.attributes
+    old_object_id = @record.instance_variable_get(:@attributes).object_id
+
+    @record.send(:reindex, %w[apple banana courier django])
+    assert_equal %w[apple banana courier django], @record.attributes
+
+    new_object_id = @record.instance_variable_get(:@attributes).object_id
+    assert_equal old_object_id, new_object_id
   end
+
 end

data/test/test_renderer.rb

@@ -2,15 +2,25 @@ require 'test/unit'
 require 'ruport'
 
 class DummyText < Ruport::Format::Plugin
+  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
 
 
@@ -27,6 +37,22 @@ class TrivialRenderer < Ruport::Renderer
 
 end
 
+class RendererWithHelpers < Ruport::Renderer
+  include Ruport::Renderer::Helpers
+
+  add_format DummyText, :text
+
+  prepare :document
+
+  option :subtitle
+
+  stage :header
+  stage :body
+  stage :footer
+
+  finalize :document
+end
+
 
 class TestRenderer < Test::Unit::TestCase
 
@@ -45,6 +71,57 @@ class TestRenderer < Test::Unit::TestCase
     assert_nil Ruport::Renderer.try_require(:not_a_plugin)
   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(RuntimeError) { RendererWithHelpers.finalize :report }
+   end
+
+   def test_prepare_again
+     assert_raise(RuntimeError) { 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_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
+     RendererWithHelpers.required_option :title
+ 
+     RendererWithHelpers.render_text do |r|
+       r.title = "Test Report"
+       assert_equal "Test Report", r.options.title
+     end
+   end
+ 
+   def test_without_required_option
+     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

data/test/test_report.rb

@@ -1,181 +1,188 @@
-#tc_report.rb
-#
-#  Created by Gregory Thomas Brown on 2005-08-09
-#  Copyright 2005 (Gregory Brown) All rights reserved.
-
-require "test/unit"
-require "ruport"
-begin; require "rubygems"; rescue LoadError; nil; end
-
-begin
-  require 'mocha'
-  require 'stubba'
-  require 'net/smtp'
-rescue LoadError
-  $stderr.puts "Warning: Mocha not found -- skipping some Report tests"
-end
-
-class TestReport < Test::Unit::TestCase
-  include Ruport
-
-  def setup
-    @report = Report.new
-    Ruport::Config.source :default, :dsn => "ruport:test", 
-                                    :user => "foo", :password => "bar" 
-    @query1 = Ruport::Query.new "select * from foo", :cache_enabled => true 
-    @query1.cached_data = [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]) 
-  end
-
-  def test_erb
-    @report = Report.new
-    @report.results = "foo"
-    assert_equal "foo", @report.erb("<%= @results %>")
-    assert_equal "foo\n4\n---\n", @report.erb("test/samples/foo.rtxt")
-  end
-
-  def test_textile
-    @report = Report.new
-    assert_equal "<p><strong>foo</strong></p>", @report.textile("*foo*")
-  end
-  
-  def test_query
-    assert_kind_of Ruport::Data::Table, 
-      @report.query("blah",:query_obj => @query1)
-    expected = [[1,2,3],[4,5,6],[7,8,9]]
-    @report.query("blah",:query_obj => @query1, :yield_type => :by_row) { |r|
-      assert_equal expected.shift, r.data
-      assert_equal %w[a b c], r.attributes
-    }
-    assert_equal "a,b,c\n1,2,3\n4,5,6\n7,8,9\n", 
-       @report.query("blah",:query_obj => @query1, :as => :csv)       
-  end
-
-  class MyReport < Report; end
-  
-  def test_klass_methods
-    rep_klass = MyReport.dup
-    rep_klass.send(:prepare)  { self.file = "foo.csv" }
-    rep_klass.send(:generate) { "hello dolly" }
-    rep_klass.send(:cleanup) { @foo = "bar" }
-    report = rep_klass.new
-    report.run { |rep|  
-      assert_equal("foo.csv",rep.file)
-      assert_equal("hello dolly",rep.results)
-      assert_equal(nil,rep.instance_eval("@foo"))
-    }
-    assert_equal("bar",report.instance_eval("@foo"))
-  end
-
-  def test_multi_reports
-    rep_klass = MyReport.dup
-    
-    report1 = rep_klass.new
-    report2 = rep_klass.new
-
-    report1.file = "foo"
-    report2.file = "bar"
-
-    rep_klass.send(:generate) { file }
-
-    expected = %w[foo bar]
-
-    rep_klass.run :reports => [report1,report2] do |rep|
-      assert_equal expected.shift, rep.results
-    end
-
-  end
-
-
-  def test_timeout
-    rep_klass = MyReport.dup
-    rep_klass.send(:generate) { raise }
-
-    assert_raises(RuntimeError){ 
-      rep_klass.run(:tries => 3, :interval => 1, :log_level => :log_only)
-    }
-    
-    rep_klass.send(:generate) { sleep 1.1 }
-
-    assert_raises(Timeout::Error) {
-      rep_klass.run( :tries    => 2, 
-                     :timeout  => 1, 
-                     :interval => 1,
-                     :log_level => :log_only)
-    }
-
-  end
-  
-  def test_return_value
-    rep_klass = MyReport.dup
-    rep_klass.send(:generate) { "hello dolly" }
-
-    # single report
-    assert_equal "hello dolly", rep_klass.run 
-
-    # multiple reports
-    assert_equal ["hello dolly", "hello dolly"],
-      rep_klass.run(:reports => [rep_klass.new,rep_klass.new])
-  end
-  
-  def test_send_to
-     return unless Object.const_defined? :Mocha
-     setup_mock_mailer
-     @report = Report.new
-     assert_equal "250 ok", @report.send_to("clyde@example.com") { |mail|
-       mail.subject = "Test Report"
-       mail.text = "Test"
-     }
-   end
- 
-   def test_write_to_file
-     return unless Object.const_defined? :Mocha
-     setup_mock_file
-     @report = Report.new
-     assert @report.write("foo.csv")
-   end
- 
-   def test_append_to_file
-     return unless Object.const_defined? :Mocha
-     setup_mock_file
-     @report = Report.new
-     assert @report.append("foo.csv")
-   end
- 
-   def test_load_csv
-     expected = [%w[a b c],['d', nil, 'e']].to_table(%w[col1 col2 col3])
- 
-     @report = Report.new
-     table = @report.load_csv("test/samples/data.csv")
- 
-     assert_equal expected, table
-   end
- 
-   def test_load_csv_as_array
-     expected = [%w[a b c],['d', nil, 'e']]
- 
-     @report = Report.new
-     array = @report.load_csv("test/samples/data.csv", :as => :array)
- 
-     assert_equal expected, array
-   end
- 
-   private
- 
-   def setup_mock_mailer
-     @smtp     = mock('smtp')
- 
-     Net::SMTP.expects(:start).
-       yields(@smtp).
-       returns("250 ok").at_least_once
-     @smtp.stubs(:send_message).
-       returns("250 ok")
-   end
- 
-   def setup_mock_file
-     @file = mock("file")
- 
-     File.expects(:open).yields(@file).returns(@file).at_least_once
-     @file.expects(:<<).returns(@file).at_least_once
-   end
-
-end
+#tc_report.rb
+#
+#  Created by Gregory Thomas Brown on 2005-08-09
+#  Copyright 2005 (Gregory Brown) All rights reserved.
+
+require "test/unit"
+require "ruport"
+begin; require "rubygems"; rescue LoadError; nil; end
+
+begin
+  require 'mocha'
+  require 'stubba'
+  require 'net/smtp'
+rescue LoadError
+  $stderr.puts "Warning: Mocha not found -- skipping some Report tests"
+end
+
+class TestReport < Test::Unit::TestCase
+  include Ruport
+
+  def setup
+    @report = Report.new
+    Ruport::Config.source :default, :dsn => "ruport:test", 
+                                    :user => "foo", :password => "bar" 
+    @query1 = Ruport::Query.new "select * from foo", :cache_enabled => true 
+    @query1.cached_data = [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]) 
+  end
+
+  def test_erb
+    @report = Report.new
+    @report.results = "foo"
+    assert_equal "foo", @report.erb("<%= @results %>")
+    assert_equal "foo\n4\n---\n", @report.erb("test/samples/foo.rtxt")
+  end
+
+  def test_textile
+    @report = Report.new
+    assert_equal "<p><strong>foo</strong></p>", @report.textile("*foo*")
+  end
+  
+  def test_query
+    assert_kind_of Ruport::Data::Table, 
+      @report.query("blah",:query_obj => @query1)
+    expected = [[1,2,3],[4,5,6],[7,8,9]]
+    @report.query("blah",:query_obj => @query1, :yield_type => :by_row) { |r|
+      assert_equal expected.shift, r.to_a
+      assert_equal %w[a b c], r.attributes
+    }
+    assert_equal "a,b,c\n1,2,3\n4,5,6\n7,8,9\n", 
+       @report.query("blah",:query_obj => @query1, :as => :csv)       
+  end
+
+  class MyReport < Report; end
+  
+  def test_klass_methods
+    rep_klass = MyReport.dup
+    rep_klass.send(:prepare)  { self.file = "foo.csv" }
+    rep_klass.send(:generate) { "hello dolly" }
+    rep_klass.send(:cleanup) { @foo = "bar" }
+    report = rep_klass.new
+    report.run { |rep|  
+      assert_equal("foo.csv",rep.file)
+      assert_equal("hello dolly",rep.results)
+      assert_equal(nil,rep.instance_eval("@foo"))
+    }
+    assert_equal("bar",report.instance_eval("@foo"))
+  end
+
+  def test_multi_reports
+    rep_klass = MyReport.dup
+    
+    report1 = rep_klass.new
+    report2 = rep_klass.new
+
+    report1.file = "foo"
+    report2.file = "bar"
+
+    rep_klass.send(:generate) { file }
+
+    expected = %w[foo bar]
+
+    rep_klass.run :reports => [report1,report2] do |rep|
+      assert_equal expected.shift, rep.results
+    end
+
+  end
+
+
+  def test_timeout
+    rep_klass = MyReport.dup
+    rep_klass.send(:generate) { raise }
+
+    assert_raises(RuntimeError){ 
+      rep_klass.run(:tries => 3, :interval => 1, :log_level => :log_only)
+    }
+    
+    rep_klass.send(:generate) { sleep 1.1 }
+
+    assert_raises(Timeout::Error) {
+      rep_klass.run( :tries    => 2, 
+                     :timeout  => 1, 
+                     :interval => 1,
+                     :log_level => :log_only)
+    }
+
+  end
+  
+  def test_return_value
+    rep_klass = MyReport.dup
+    rep_klass.send(:generate) { "hello dolly" }
+
+    # single report
+    assert_equal "hello dolly", rep_klass.run 
+
+    # multiple reports
+    assert_equal ["hello dolly", "hello dolly"],
+      rep_klass.run(:reports => [rep_klass.new,rep_klass.new])
+  end
+  
+  def test_send_to
+     return unless Object.const_defined? :Mocha
+     setup_mock_mailer
+     @report = Report.new
+     assert_equal "250 ok", @report.send_to("clyde@example.com") { |mail|
+       mail.subject = "Test Report"
+       mail.text = "Test"
+     }
+   end
+ 
+   def test_write_to_file
+     return unless Object.const_defined? :Mocha
+     file = mock("file")
+ 
+     File.expects(:open).
+       with("foo.csv","w").yields(file).returns(file).at_least_once
+
+     file.expects(:<<).
+       with("results").returns(file).at_least_once
+     
+     @report = Report.new
+     assert @report.write("foo.csv", "results")
+   end
+ 
+   def test_append_to_file
+     return unless Object.const_defined? :Mocha
+     file = mock("file")
+     
+     File.expects(:open).
+       with("foo.csv","a").yields(file).returns(file).at_least_once
+
+     file.expects(:<<).
+       with("results").returns(file).at_least_once
+ 
+     @report = Report.new
+     assert @report.append("foo.csv", "results")
+   end
+ 
+   def test_load_csv
+     expected = [%w[a b c],['d', nil, 'e']].to_table(%w[col1 col2 col3])
+ 
+     @report = Report.new
+     table = @report.load_csv("test/samples/data.csv")
+ 
+     assert_equal expected, table
+   end
+ 
+   def test_load_csv_as_array
+     expected = [%w[a b c],['d', nil, 'e']]
+ 
+     @report = Report.new
+     array = @report.load_csv("test/samples/data.csv", :as => :array)
+ 
+     assert_equal expected, array
+   end
+ 
+   private
+ 
+   def setup_mock_mailer
+     @smtp     = mock('smtp')
+ 
+     Net::SMTP.expects(:start).
+       yields(@smtp).
+       returns("250 ok").at_least_once
+     @smtp.stubs(:send_message).
+       returns("250 ok")
+   end
+ 
+end