ruport 1.6.3 → 1.8.0

data/test/record_test.rb

@@ -1,75 +1,75 @@
-#!/usr/bin/env ruby -w   
+#!/usr/bin/env ruby -w
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
-class TestRecord < Test::Unit::TestCase
+class TestRecord < Minitest::Test
 
   include Ruport::Data
-  
+
   def setup
     @attributes = %w[a b c d]
-    @record = Ruport::Data::Record.new [1,2,3,4], :attributes => @attributes 
-  end   
-  
-  context "when initializing with an array with attributes" do 
-    def specify_key_access_should_work
+    @record = Ruport::Data::Record.new [1,2,3,4], :attributes => @attributes
+  end
+
+  context "when initializing with an array with attributes" do
+    should "test_specify_key_access_should_work" do
       assert_equal 1, @record["a"]
       assert_equal 4, @record["d"]
       assert_equal 2, @record.b
       assert_equal 3, @record.c
-      assert_raise(NoMethodError) { @record.f }        
-    end  
-    
-    def specify_ordinal_access_should_work
+      assert_raises(NoMethodError) { @record.f }
+    end
+
+    should "test_specify_ordinal_access_should_work" do
       assert_equal 1, @record[0]
       assert_equal 2, @record[1]
       assert_equal 3, @record[2]
       assert_equal 4, @record[3]
     end
-  end  
-      
+  end
+
   context "when initializing with an array without attributes" do
-    def specify_ordinal_access_should_work
+    should "test_specify_ordinal_access_should_work" do
       record = Ruport::Data::Record.new [1,2,3,4]
       assert_equal 1, record[0]
       assert_equal 2, record[1]
       assert_equal 3, record[2]
-      assert_equal 4, record[3]   
-    end 
-  end         
-  
-  context "when initializing with a hash without attributes" do    
-    def setup  
+      assert_equal 4, record[3]
+    end
+  end
+
+  describe "when initializing with a hash without attributes" do
+    def setup
       @record = Ruport::Data::Record.new({:a => 1, :b => 2, :c => 3},{})
-    end     
-     
-    def specify_key_access_should_work
+    end
+
+    def test_specify_key_access_should_work
       assert_equal 1, @record[:a]
       assert_equal 2, @record[:b]
       assert_equal 3, @record[:c]
-      assert_equal 3, @record.c  
-    end  
+      assert_equal 3, @record.c
+    end
   end
-  
-  context "when initializing with a hash with attributes" do
+
+  describe "when initializing with a hash with attributes" do
     def setup
-      @record = Record.new({:a => 1, :b => 2, :c => 3 }, 
+      @record = Record.new({:a => 1, :b => 2, :c => 3 },
                            :attributes => [:c,:b,:a])
-    end   
-    
-    def specify_key_access_should_work
+    end
+
+    def test_specify_key_access_should_work
       assert_equal 1, @record[:a]
       assert_equal 2, @record[:b]
       assert_equal 3, @record[:c]
-      assert_equal 3, @record.c   
+      assert_equal 3, @record.c
     end
-    
-    def specify_ordinal_access_should_work    
+
+    def test_specify_ordinal_access_should_work
       assert_equal 3, @record[0]
-      assert_equal 2, @record[1]           
-      assert_equal 1, @record[2]           
+      assert_equal 2, @record[1]
+      assert_equal 1, @record[2]
     end
   end
-  
+
   def test_bracket_equals
     @record[1] = "godzilla"
     @record["d"] = "mothra"
@@ -80,25 +80,25 @@ class TestRecord < Test::Unit::TestCase
     assert_equal @record[3], "mothra"
     assert_equal @record["d"], "mothra"
   end
-    
+
   def test_accessors
     assert_equal @record.a, @record["a"]
     assert_equal @record.b, @record["b"]
     assert_equal @record.c, @record["c"]
     assert_equal @record.d, @record["d"]
-  end            
-  
+  end
+
   def test_can_has_id
-     record = Ruport::Data::Record.new(:id => 12345) 
+     record = Ruport::Data::Record.new(:id => 12345)
      assert_equal 12345, record.id
   end
 
   def test_nonexistent_accessor
-    assert_raise NoMethodError do
+    assert_raises NoMethodError do
       @record.e
     end
   end
-  
+
   def test_attribute_setting
     @record.a = 10
     @record.b = 20
@@ -112,24 +112,24 @@ class TestRecord < Test::Unit::TestCase
   end
 
   def test_to_hash
-    assert_nothing_raised { @record.to_hash }
+    @record.to_hash
     assert_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 }, @record.to_hash)
-  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   
+  end
 
   def test_equality
 
     dc  = %w[a b c d]
     dc2 = %w[a b c d]
     dc3 = %w[a b c]
-    
+
     rec1 = Record.new [1,2,3,4]
     rec2 = Record.new [1,2,3,4]
     rec3 = Record.new [1,2]
@@ -137,7 +137,7 @@ class TestRecord < Test::Unit::TestCase
     rec5 = Record.new [1,2,3,4], :attributes => dc2
     rec6 = Record.new [1,2,3,4], :attributes => dc3
     rec7 = Record.new [1,2],     :attributes => dc
-    
+
     [:==, :eql?].each do |op|
       assert   rec1.send(op, rec2)
       assert   rec4.send(op, rec5)
@@ -162,7 +162,7 @@ class TestRecord < Test::Unit::TestCase
 
     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.to_a
     assert_equal %w[a d b c], @record.attributes
@@ -175,10 +175,10 @@ class TestRecord < Test::Unit::TestCase
     assert_equal [1,2,3], r.to_a
     assert_equal %w[a b c], r.attributes
 
-    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" }
+    assert_raises(ArgumentError) { r.dup.reorder "foo" }
+    assert_raises(ArgumentError) { r.dup.reorder 0,5 }
+    r.dup.reorder 0
+    r.dup.reorder "a","b"
   end
 
   def test_dup
@@ -199,12 +199,12 @@ class TestRecord < Test::Unit::TestCase
     s = Record.new :attributes => %w[a b], :data => [1,2]
     assert_equal r.hash, s.hash
   end
-  
+
   def test_records_with_differing_attrs_and_data_hash_differently
     r = Record.new [1,2],:attributes => %w[a b]
     s = Record.new [nil,nil],:attributes => %w[a b]
     assert r.hash != s.hash
-    
+
     t = Record.new [1,3],:attributes => %w[a b]
     assert r.hash != t.hash
   end
@@ -225,7 +225,7 @@ class TestRecord < Test::Unit::TestCase
     new_object_id = @record.instance_variable_get(:@attributes).object_id
     assert_equal a.object_id, new_object_id
   end
-  
+
   #----------------------------------------------------------------------
   #  BUG Traps
   #----------------------------------------------------------------------
@@ -245,35 +245,35 @@ class TestRecord < Test::Unit::TestCase
   end
 
   # Ticket #172
-  def test_ensure_get_really_indifferent   
+  def test_ensure_get_really_indifferent
     a = Record.new({"a" => 1, "b" => 2})
     assert_equal(2,a.get("b"))
     assert_equal(2,a.get(:b))
-    a = Record.new({:a => 1, :b => 2})    
+    a = Record.new({:a => 1, :b => 2})
     assert_equal(2,a.get("b"))
     assert_equal(2,a.get(:b))
   end
-  
+
   def test_ensure_get_throws_argument_error
     a = Record.new({"a" => 1, "b" => 2})
     assert_raises(ArgumentError) { a.get([]) }
   end
-  
+
   def test_ensure_delete_removes_attribute
     a = Record.new({"a" => 1, "b" => 2})
     assert_equal({"a" => 1, "b" => 2}, a.data)
     assert_equal(["a","b"], a.attributes)
-    
+
     a.send(:delete, "a")
     assert_equal({"b" => 2}, a.data)
     assert_equal(["b"], a.attributes)
   end
-  
+
   def test_ensure_bracket_equals_updates_attributes
     a = Record.new({"a" => 1, "b" => 2})
     assert_equal({"a" => 1, "b" => 2}, a.data)
     assert_equal(["a","b"], a.attributes)
-    
+
     a["b"] = 3
     assert_equal({"a" => 1, "b" => 3}, a.data)
     assert_equal(["a","b"], a.attributes)
@@ -289,44 +289,44 @@ class TestRecord < Test::Unit::TestCase
     a = MyRecordSub.new [1,2,3]
     assert_equal "1,2,3\n", a.to_csv
   end
-    
-  context "when rendering records" do   
-    
-    def specify_record_as_should_work
+
+  context "when rendering records" do
+
+    should "test_specify_record_as_should_work" do
       rendered_row = @record.as(:text)
       assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)
     end
 
-    def specify_record_to_format_should_work_without_options
+    should "test_specify_record_to_format_should_work_without_options" do
       rendered_row = @record.to_text
-      assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)    
-    end             
-         
-    def specify_record_to_format_should_work_with_options
+      assert_equal("| 1 | 2 | 3 | 4 |\n", rendered_row)
+    end
+
+    should "test_specify_record_to_format_should_work_with_options" do
       rendered_row = @record.to_csv(:format_options => { :col_sep => "\t"})
-      assert_equal("1\t2\t3\t4\n",rendered_row)     
-    end                                      
-    
-    context "when given bad format names" do
-      def setup 
-        @a = Record.new({ "a" => 1, "b" => 2 }) 
+      assert_equal("1\t2\t3\t4\n",rendered_row)
+    end
+
+    describe "when given bad format names" do
+      def setup
+        @a = Record.new({ "a" => 1, "b" => 2 })
       end
 
-      def specify_as_should_throw_proper_errors
-        assert_raises(Ruport::Controller::UnknownFormatError) { @a.as(:nothing) } 
-      end 
-    
-      def specify_to_format_should_throw_proper_errors
+      def test_specify_as_should_throw_proper_errors
+        assert_raises(Ruport::Controller::UnknownFormatError) { @a.as(:nothing) }
+      end
+
+      def test_specify_to_format_should_throw_proper_errors
         assert_raises(Ruport::Controller::UnknownFormatError) { @a.to_nothing }
-      end  
-    end   
-  
+      end
+    end
+
     ## -- BUG TRAPS --------------------
-  
-    def specify_attributes_should_not_be_broken_by_to_hack
+
+    should "test_specify_attributes_should_not_be_broken_by_to_hack" do
       record = Ruport::Data::Record.new [1,2], :attributes => %w[a to_something]
       assert_equal 2, record.to_something
-    end                              
+    end
   end
 
 end

data/test/samples/sales.csv

@@ -0,0 +1,21 @@
+Region,Product,Units Sold
+North,Widget,8
+South,Gadget,2
+East,Gizmo,8
+West,Widget,6
+South,Widget,6
+East,Gadget,5
+West,Gizmo,1
+East,Gadget,1
+West,Widget,4
+West,Gadget,8
+North,Gizmo,2
+South,Gizmo,5
+East,Widget,3
+North,Gadget,1
+South,Gizmo,7
+North,Gizmo,8
+North,Widget,4
+East,Gadget,4
+West,Gizmo,6
+South,Gadget,3

data/test/table_pivot_test.rb

@@ -1,10 +1,10 @@
-#!/usr/bin/env ruby -w   
+#!/usr/bin/env ruby -w
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
-class TablePivotSimpleCaseTest < Test::Unit::TestCase
+class TablePivotSimpleCaseTest < Minitest::Test
 
   def setup
-    table = Table('a', 'b', 'c')
+    table = Ruport.Table('a', 'b', 'c')
     table << [1,3,6]
     table << [1,4,7]
     table << [2,3,8]
@@ -17,18 +17,23 @@ class TablePivotSimpleCaseTest < Test::Unit::TestCase
   end
 
   def test_produces_correct_full_table
-    expected = Table("a",3,4) { |t| t << [1,6,7] << [2,8,9] }
+    expected = Ruport.Table("a",3,4) { |t| t << [1,6,7] << [2,8,9] }
     assert_equal(expected, @pivoted)
   end
 
+  def test_pivot_empty_table
+    tab = Ruport.Table ["id", "num_sessions", "status", "diagnosis"]
+    tab <<             ["one", 10,            :aborted, :good]
+    tab <<             ["two", 10,            :success, :bad]
+
+    tab.pivot("status", :group_by=>"diagnosis", :values=>"num_sessions", :operation=>:mean)
+  end
 end
 
-class PivotConvertRowOrderToGroupOrderTest < Test::Unit::TestCase
+class PivotConvertRowOrderToGroupOrderTest < Minitest::Test
 
-  def convert(src)
-    Ruport::Data::Table::Pivot.new(
-      nil, nil, nil, nil
-    ).convert_row_order_to_group_order(src)
+  def convert(row_order)
+    Ruport::Data::Table::Pivot.row_order_to_group_order(row_order)
   end
 
   def setup
@@ -57,15 +62,15 @@ class PivotConvertRowOrderToGroupOrderTest < Test::Unit::TestCase
   end
 
   def test_nil
-    assert_equal(nil, convert(nil))
+    assert_nil convert(nil)
   end
 
 end
 
-class PivotPreservesOrdering < Test::Unit::TestCase
+class PivotPreservesOrdering < Minitest::Test
 
-  def test_group_column_entries_preserves_order_of_occurrence
-    table = Table('group', 'a', 'b')
+  def test_group_column_preserves_order_of_occurrence
+    table = Ruport.Table('group', 'a', 'b')
     [
       [1, 0, 0],
       [9, 0, 0],
@@ -75,13 +80,13 @@ class PivotPreservesOrdering < Test::Unit::TestCase
       [8, 0, 0],
       [1, 0, 0]
     ].each {|e| table << e}
-    assert_equal([1,9,8], 
+    assert_equal([1,9,8],
        Ruport::Data::Table::Pivot.
-       new(table, 'group', 'a', 'b').group_column_entries)
+       new(table, 'group', 'a', 'b').column)
   end
 
-  def test_resulting_columns_preserve_ordering_of_rows
-    table = Table('group', 'a', 'b', 'c')
+  def test_pivoted_row_preserves_order_of_input_rows
+    table = Ruport.Table('group', 'a', 'b', 'c')
     [
       [200,   1, 2, 1],
       [200,   4, 5, 2],
@@ -93,11 +98,11 @@ class PivotPreservesOrdering < Test::Unit::TestCase
       [1,4,5],
       Ruport::Data::Table::Pivot.new(
         table, 'group', 'a', 'b', :pivot_order => ['c']
-      ).columns_from_pivot)
+      ).row)
   end
 
   def test_preserves_ordering
-    table = Table('group', 'a', 'b', 'c')
+    table = Ruport.Table('group', 'a', 'b', 'c')
     [
       [200,   1, 2, 3],
       [200,   4, 5, 6],
@@ -105,30 +110,76 @@ class PivotPreservesOrdering < Test::Unit::TestCase
       [100,   4,11,12]
     ].each {|e| table << e}
     pivoted = table.pivot('a', :group_by => 'group', :values => 'b')
-    expected = Table("group",1,4) { |t| t << [200,2,5] << [100,8,11] }
+    expected = Ruport.Table("group",1,4) { |t| t << [200,2,5] << [100,8,11] }
     assert_equal(expected, pivoted)
   end
 
-  def test_preserves_ordering_on_calculated_column
-    table = Table('group', 'a')
+  def test_reorders_a_calculated_column_by_column_name
+    table = Ruport.Table('group', 'a')
     [
       [1, 1], [2, 2], [3, 3]
     ].each {|e| table << e}
     table.add_column('pivotme') {|row| 10 - row.group.to_i}
-    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a', 
+    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a',
                                      :pivot_order => :name)
     assert_equal(['group', 7, 8, 9], pivoted.column_names)
   end
 
   def test_preserves_ordering_on_calculated_column_with_proc_pivot_order
-    table = Table('group', 'a')
+    table = Ruport.Table('group', 'a')
     [
       [1, 1], [2, 2], [3, 3]
     ].each {|e| table << e}
     table.add_column('pivotme') {|row| 10 - row.group.to_i}
-    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a', 
-                                     :pivot_order => proc {|row, pivot| pivot })
+    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a',
+                                     :pivot_order => proc {|_row, pivot| pivot })
     assert_equal(['group', 7, 8, 9], pivoted.column_names)
   end
 
 end
+
+class TablePivotOperationTest < Minitest::Test
+  def setup
+    @rows = [
+      Ruport::Data::Record.new('Values' => 3),
+      Ruport::Data::Record.new('Values' => 9),
+      Ruport::Data::Record.new('Values' => 4)
+    ]
+  end
+
+  def test_performs_operation_sum
+    sum = Ruport::Data::Table::Pivot::Operations.sum(@rows, 'Values')
+    assert_equal 16, sum
+  end
+
+  def test_performs_operation_first
+    first = Ruport::Data::Table::Pivot::Operations.first(@rows, 'Values')
+    assert_equal 3, first
+  end
+
+  def test_performs_operation_count
+    count = Ruport::Data::Table::Pivot::Operations.count(@rows, 'Values')
+    assert_equal 3, count
+  end
+
+  def test_performs_operation_mean
+    mean = Ruport::Data::Table::Pivot::Operations.mean(@rows, 'Values')
+    assert_equal 5, mean
+  end
+
+  def test_performs_operation_min
+    min = Ruport::Data::Table::Pivot::Operations.min(@rows, 'Values')
+    assert_equal 3, min
+  end
+
+  def test_performs_operation_max
+    max = Ruport::Data::Table::Pivot::Operations.max(@rows, 'Values')
+    assert_equal 9, max
+  end
+
+  def test_invalid_operation_causes_exception
+    assert_raises ArgumentError do
+      Ruport::Data::Table::Pivot.new(nil, nil, nil, nil, :operation => :foo)
+    end
+  end
+end