ruport 1.6.3 → 1.8.0

data/test/grouping_test.rb

@@ -1,14 +1,14 @@
-#!/usr/bin/env ruby -w   
+#!/usr/bin/env ruby -w
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
-class TestGroup < Test::Unit::TestCase
+class TestGroup < Minitest::Test
 
   def setup
     @group = Ruport::Data::Group.new(:name => 'test',
                                      :data => [[1,2,3]],
                                      :column_names => %w[a b c])
   end
-  
+
   def test_group_constructor
     group = Ruport::Data::Group.new(:name => 'test',
                                     :data => [[1,2,3]],
@@ -34,7 +34,7 @@ class TestGroup < Test::Unit::TestCase
   end
 
   def test_eql
-    table = Table(%w[a b c], :data => [[1,2,3]])
+    table = Ruport.Table(%w[a b c], :data => [[1,2,3]])
 
     group2 = Ruport::Data::Group.new(:name => 'test',
                                      :data => [[1,2,3]],
@@ -44,7 +44,7 @@ class TestGroup < Test::Unit::TestCase
     assert_equal @group, group2
     assert_equal @group, @group.dup
   end
-  
+
   def test_create_subgroups
     group = @group << [4,5,6]
     group.send(:create_subgroups, "a")
@@ -55,7 +55,7 @@ class TestGroup < Test::Unit::TestCase
                                         :column_names => %w[b c],
                                         :name => 4 ) }
     assert_equal b, group.subgroups
-    
+
     group.send(:create_subgroups, "b")
     c = { 2 => Ruport::Data::Group.new( :data => [[3]],
                                         :column_names => %w[c],
@@ -65,8 +65,8 @@ class TestGroup < Test::Unit::TestCase
                                         :name => 5 ) }
     assert_equal c, group.subgroups[1].subgroups
     assert_equal d, group.subgroups[4].subgroups
-  end    
-  
+  end
+
   def test_grouped_data
     a = @group << [4,5,6]
     b = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
@@ -79,24 +79,25 @@ class TestGroup < Test::Unit::TestCase
   end
 end
 
-class TestGroupRendering < Test::Unit::TestCase
+class TestGroupRendering < Minitest::Test
 
   def setup
     @group = Ruport::Data::Group.new(:name => 'test',
                                      :data => [[1,2,3]],
                                      :column_names => %w[a b c])
-  end       
+  end
 
   def test_group_as
-    assert_equal(7, @group.to_text.to_a.length)
+    assert_equal(7, @group.to_text.split("\n").size)
     assert_equal(5, @group.as(:text,
-                              :show_table_headers => false).to_a.length)
-    assert_equal(13, @group.to_html.to_a.length)
+                              :show_table_headers => false).split("\n").size)
+    assert_equal(15, @group.to_html.split("\n").size)
+    assert_equal(8, @group.to_html(:show_table_headers => false).split("\n").size)
   end
-  
+
   def test_as_throws_proper_errors
-    assert_nothing_raised { @group.as(:csv) }
-    assert_nothing_raised { @group.to_csv }
+    @group.as(:csv)
+    @group.to_csv
     assert_raises(Ruport::Controller::UnknownFormatError) {
       @group.as(:nothing) }
     assert_raises(Ruport::Controller::UnknownFormatError) {
@@ -110,16 +111,16 @@ class TestGroupRendering < Test::Unit::TestCase
     assert_equal "1\n\nb,c\n2,3\n", t.to_csv
   end
 end
-    
-class TestGrouping < Test::Unit::TestCase
-  
+
+class TestGrouping < Minitest::Test
+
   def setup
-    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    table = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     @grouping = Ruport::Data::Grouping.new(table, :by => "a")
   end
-  
+
   def test_grouping_constructor
-    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     b = Ruport::Data::Grouping.new(a, :by => "a")
     c = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],
@@ -128,24 +129,24 @@ class TestGrouping < Test::Unit::TestCase
                                         :column_names => %w[b c],
                                         :name => 4 ) }
     assert_equal c, b.data
-  end        
-  
+  end
+
   def test_empty_grouping
     a = Ruport::Data::Grouping.new()
     a << Group("foo",:data => [[1,2,3],[4,5,6]],
                      :column_names => %w[a b c] )
-    assert_equal "foo", a["foo"].name    
-    assert_nil a.grouped_by         
-  end                               
-  
+    assert_equal "foo", a["foo"].name
+    assert_nil a.grouped_by
+  end
+
   def test_empty_grouping_with_grouped_by
-    a = Ruport::Data::Grouping.new(:by => "nada")  
+    a = Ruport::Data::Grouping.new(:by => "nada")
     a << Group("foo",:data => [[1,2,3],[4,5,6]],
                      :column_names => %w[a b c] )
-    assert_equal "foo", a["foo"].name    
+    assert_equal "foo", a["foo"].name
     assert_equal "nada", a.grouped_by
   end
-  
+
   def test_grouping_indexing
     a = [Ruport::Data::Group.new( :data => [[2,3]],
                                   :column_names => %w[b c],
@@ -159,8 +160,8 @@ class TestGrouping < Test::Unit::TestCase
     assert_equal a[0], @grouping[1]
     assert_equal a[1], @grouping[4]
     assert_raises(IndexError) { @grouping[2] }
-  end    
-  
+  end
+
   def test_should_copy_grouping
     a = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],
@@ -174,19 +175,19 @@ class TestGrouping < Test::Unit::TestCase
   end
 
   def test_append
-   a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+   a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
    @grouping << a.to_group("red snapper")
    assert_equal @grouping["red snapper"], a.to_group("red snapper")
-   
+
    assert_raises(ArgumentError) { @grouping << a.to_group("red snapper") }
   end
-  
+
   def test_grouped_by
     assert_equal "a", @grouping.grouped_by
   end
 
   def test_grouping_on_multiple_columns
-    a = Table(%w[a b c d], :data => [[1,2,3,4],[4,5,6,7]])
+    a = Ruport.Table(%w[a b c d], :data => [[1,2,3,4],[4,5,6,7]])
     b = Ruport::Data::Grouping.new(a, :by => %w[a b c])
     c = { 1 => Ruport::Data::Group.new( :data => [[2,3,4]],
                                         :column_names => %w[b c d],
@@ -204,10 +205,10 @@ class TestGrouping < Test::Unit::TestCase
                                         :name => 5 ) }
     assert_equal d, b[1].subgroups
     assert_equal e, b[4].subgroups
-  end      
+  end
 
   def test_subgrouping
-    a = Table(%w[first_name last_name id])
+    a = Ruport.Table(%w[first_name last_name id])
     a << %w[ greg brown awesome ]
     a << %w[ mike milner schweet ]
     a << %w[ greg brown sick ]
@@ -219,7 +220,7 @@ class TestGrouping < Test::Unit::TestCase
     sub = (g / "mike")["milner"]
     assert_equal %w[schweet], sub.column("id")
   end
-  
+
   class TicketStatus < Ruport::Data::Record
 
     def closed
@@ -231,41 +232,41 @@ class TestGrouping < Test::Unit::TestCase
     end
 
   end
-  
+
   def test_grouping_summary
-    source = Table(File.join(File.expand_path(File.dirname(__FILE__)), 
+    source = Ruport.Table(File.join(File.expand_path(File.dirname(__FILE__)),
                    *%w[samples ticket_count.csv]),
                      :record_class => TicketStatus)
     grouping = Grouping(source,:by => "date")
-    
-    expected = Table(:date, :opened,:closed)
+
+    expected = Ruport.Table(:date, :opened,:closed)
     grouping.each do |date,group|
       opened = group.sigma { |r| r.opened  }
       closed = group.sigma { |r| r.closed  }
       expected << { :date => date, :opened => opened, :closed => closed }
     end
-    
+
     actual = grouping.summary :date,
       :opened => lambda { |g| g.sigma(:opened) },
       :closed => lambda { |g| g.sigma(:closed) },
       :order => [:date,:opened,:closed]
-      
+
     assert_equal expected, actual
-    
+
     actual = grouping.summary :date,
       :opened => lambda { |g| g.sigma(:opened) },
       :closed => lambda { |g| g.sigma(:closed) }
-      
-    assert_equal [], expected.column_names - actual.column_names       
-  end                                                              
-  
+
+    assert_equal [], expected.column_names - actual.column_names
+  end
+
   def test_grouping_sigma
     assert_respond_to @grouping, :sigma
     assert_respond_to @grouping, :sum
-    
+
     expected = {}
     @grouping.data[@grouping.data.keys.first].column_names.each do |col|
-      expected[col] = @grouping.inject(0) do |s, (group_name, group)|
+      expected[col] = @grouping.inject(0) do |s, (_group_name, group)|
         s + group.sigma(col)
       end
     end
@@ -275,7 +276,7 @@ class TestGrouping < Test::Unit::TestCase
 
     expected = {}
     @grouping.data[@grouping.data.keys.first].column_names.each do |col|
-      expected[col] = @grouping.inject(0) do |s, (group_name, group)|
+      expected[col] = @grouping.inject(0) do |s, (_group_name, group)|
         s + group.sigma {|r| r[col] + 2 }
       end
     end
@@ -284,101 +285,101 @@ class TestGrouping < Test::Unit::TestCase
     end
   end
 
-  context "when sorting groupings" do
-    
+  describe "when sorting groupings" do
+
     def setup
-      @table = Table(%w[a b c]) << ["dog",1,2] << ["cat",3,5] << 
+      @table = Ruport.Table(%w[a b c]) << ["dog",1,2] << ["cat",3,5] <<
                                    ["banana",8,1] << ["dog",5,6] << ["dog",2,4] << ["banana",7,9]
     end
-    
-    def specify_can_set_by_group_name_order_in_constructor
-      a = Grouping(@table, :by => "a", :order => :name)    
-      names = %w[banana cat dog]           
+
+    def test_specify_can_set_by_group_name_order_in_constructor
+      a = Grouping(@table, :by => "a", :order => :name)
+      names = %w[banana cat dog]
       data = [ [[8,1],[7,9]], [[3,5]], [[1,2],[5,6],[2,4]] ]
       a.each do |name,group|
         assert_equal names.shift, name
-        assert_equal data.shift, group.map { |r| r.to_a } 
+        assert_equal data.shift, group.map { |r| r.to_a }
       end
     end
-    
-    def specify_can_set_by_proc_ordering_in_constructor
-      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } ) 
-      names = %w[dog banana cat]      
+
+    def test_specify_can_set_by_proc_ordering_in_constructor
+      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )
+      names = %w[dog banana cat]
       data = [ [[1,2],[5,6],[2,4]], [[8,1],[7,9]], [[3,5]] ]
       a.each do |name,group|
         assert_equal names.shift, name
-        assert_equal data.shift, group.map { |r| r.to_a } 
+        assert_equal data.shift, group.map { |r| r.to_a }
       end
-    end  
-    
-    def specify_can_override_sorting
-      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )  
+    end
+
+    def test_specify_can_override_sorting
+      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )
       a.sort_grouping_by!(:name)
-      names = %w[banana cat dog]           
+      names = %w[banana cat dog]
       data = [ [[8,1],[7,9]], [[3,5]], [[1,2],[5,6],[2,4]] ]
       a.each do |name,group|
         assert_equal names.shift, name
-        assert_equal data.shift, group.map { |r| r.to_a } 
+        assert_equal data.shift, group.map { |r| r.to_a }
       end
-    end 
-    
-    def specify_can_get_a_new_sorted_grouping
-      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )  
-      b = a.sort_grouping_by(:name)     
-      
-      names = %w[banana cat dog]           
+    end
+
+    def test_specify_can_get_a_new_sorted_grouping
+      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )
+      b = a.sort_grouping_by(:name)
+
+      names = %w[banana cat dog]
       data = [ [[8,1],[7,9]], [[3,5]], [[1,2],[5,6],[2,4]] ]
       b.each do |name,group|
         assert_equal names.shift, name
-        assert_equal data.shift, group.map { |r| r.to_a } 
+        assert_equal data.shift, group.map { |r| r.to_a }
       end
-      
+
       # assert original retained
-      names = %w[dog banana cat]      
+      names = %w[dog banana cat]
       data = [ [[1,2],[5,6],[2,4]], [[8,1],[7,9]], [[3,5]] ]
       a.each do |name,group|
         assert_equal names.shift, name
-        assert_equal data.shift, group.map { |r| r.to_a } 
-      end   
+        assert_equal data.shift, group.map { |r| r.to_a }
+      end
     end
   end
- 
+
   class MyRecord < Ruport::Data::Record; end
-  
+
   def test_grouping_should_set_record_class
-    a = Table(%w[a b c], :record_class => MyRecord) { |t| 
+    a = Ruport.Table(%w[a b c], :record_class => MyRecord) { |t|
           t << [1,2,3]
           t << [4,5,6]
         }
     b = Ruport::Data::Grouping.new(a, :by => "a")
     assert_equal MyRecord, b[1].record_class
-  end   
+  end
 
   class MyGroupingSub < Ruport::Data::Grouping; end
 
   def test_ensure_grouping_subclasses_render_properly
-    t = Table(%w[a b c]) << [1,2,3]
-    a = MyGroupingSub.new(t, :by => "a") 
+    t = Ruport.Table(%w[a b c]) << [1,2,3]
+    a = MyGroupingSub.new(t, :by => "a")
     assert_equal "1\n\nb,c\n2,3\n\n", a.to_csv
   end
 end
 
-class TestGroupingRendering < Test::Unit::TestCase
+class TestGroupingRendering < Minitest::Test
 
   def setup
-    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    table = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     @grouping = Ruport::Data::Grouping.new(table, :by => "a")
   end
-  
+
   def test_grouping_as
-    assert_equal(16, @grouping.to_text.to_a.length)
-    assert_equal(12, @grouping.as(:text,
-      :show_table_headers => false).to_a.length)
+    assert_equal(15, @grouping.to_text.split("\n").size)
+    assert_equal(11, @grouping.as(:text,
+      :show_table_headers => false).split("\n").size)
   end
 
   def test_as_throws_proper_errors
-    assert_nothing_raised { @grouping.as(:csv) }
-    assert_nothing_raised { @grouping.to_csv }
+     @grouping.as(:csv)
+     @grouping.to_csv
     assert_raises(Ruport::Controller::UnknownFormatError) {
       @grouping.as(:nothing) }
     assert_raises(Ruport::Controller::UnknownFormatError) {
@@ -386,18 +387,18 @@ class TestGroupingRendering < Test::Unit::TestCase
   end
 end
 
-class TestGroupingKernelHacks < Test::Unit::TestCase
+class TestGroupingKernelHacks < Minitest::Test
 
   def test_group_kernel_hack
     group = Ruport::Data::Group.new( :name => 'test',
                                      :data => [[1,2,3]],
                                      :column_names => %w[a b c])
     assert_equal group, Group('test', :data => [[1,2,3]],
-                                      :column_names => %w[a b c]) 
+                                      :column_names => %w[a b c])
   end
 
   def test_grouping_kernel_hack
-    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    table = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     grouping = Ruport::Data::Grouping.new(table, :by => "a")
     a = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],

data/test/helpers.rb

@@ -1,10 +1,29 @@
-require "test/unit"
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib') 
-require "ruport"
-begin; require "rubygems"; rescue LoadError; nil; end
-require "spec-unit"
-require "mocha"
-
-class Test::Unit::TestCase
-  include SpecUnit
-end
+require 'coveralls'
+require 'simplecov'
+require 'coveralls'
+
+# Use this formatter instead if you want to see coverage locally:
+#
+# SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+#   SimpleCov::Formatter::HTMLFormatter,
+#   Coveralls::SimpleCov::Formatter
+# ])
+
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter 'test'
+end
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'ruport'
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/unit'
+require 'shoulda-context'
+require 'mocha/minitest'
+class Minitest::Test
+  include Ruport
+end
+
+TEST_SAMPLES = File.join(File.expand_path(File.dirname(__FILE__)), "samples")