elskwid-munger 0.1.4.5 → 0.1.4.6

data/test/munger/html_test.rb

@@ -0,0 +1,87 @@
+require "test_helper"
+
+describe Munger::Render::Html do
+  include MungerSpecHelper
+
+  before(:each) do
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data)
+  end
+
+  it "must accept a Munger::Report object" do
+    Munger::Render::Html.new(@report.process).must_be :valid?
+  end
+
+  it "must render a basic html table" do
+    @render = Munger::Render::Html.new(@report.process)
+    count = @report.rows
+
+    html = @render.render
+    html.must_have_tag('table')
+    html.must_have_tag('tr', :count => count + 1) # rows plus header
+  end
+
+  it "must render a thead section for the table" do
+    @render = Munger::Render::Html.new(@report.process)
+    html = @render.render
+    html.must_have_tag('thead', :count => 1)
+  end
+
+  it "must render a tbody section for the table" do
+    @render = Munger::Render::Html.new(@report.process)
+    html = @render.render
+    html.must_have_tag('tbody', :count => 1)
+  end
+
+  it "must accept a custom table class" do
+    rep = Munger::Render::Html.new(@report.process, :classes => {:table => 'helloClass'})
+    html = rep.render
+    html.must_have_tag('table.helloClass')
+  end
+
+  it "must use aliased column titles" do
+    @report = @report.columns([:age, :name, :score])
+    @report.column_titles = {:age => "The Age", :name => "The Name"}
+    html = Munger::Render::Html.new(@report.process).render
+    html.must_match(/The Age/)
+  end
+
+  it "must render columns in the right order" do
+    @report = @report.columns([:age, :name]).process
+    html = Munger::Render::Html.new(@report).render
+    html.must_have_tag('th', :count => 2) # rows plus header
+    html.must_match(/age(.*?)name/)
+  end
+
+  it "must render groups" do
+    @report = @report.subgroup(:age).aggregate(:sum => :score).process
+    html = Munger::Render::Html.new(@report).render
+    html.must_match(/151/) # only in the aggregate group
+    html.must_have_tag('tr.group0', :count => 1)
+    html.must_have_tag('tr.group1', :count => 9)
+  end
+
+  it "must render group headers" do
+    @report = @report.subgroup(:age, :with_headers => true).process
+    html = Munger::Render::Html.new(@report).render
+    html.must_have_tag('tr.groupHeader1', :count => 9)
+  end
+
+  it "must render cell styles" do
+    @report.process.style_rows('over_thirty') { |row| row.age > 29 }
+
+    html = Munger::Render::Html.new(@report).render
+    html.must_have_tag('tr.over_thirty', :count => 6)
+  end
+
+  it "must render row styles" do
+    @report.process.style_cells('highlight', :only => :age) { |c, r| c == 32 }
+    html = Munger::Render::Html.new(@report).render
+    html.must_have_tag('td.highlight')
+  end
+
+  it "must render column styles"
+
+  it "must render default css if you ask"
+
+end

data/test/munger/item_test.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+
+describe Munger::Item do
+  include MungerSpecHelper
+
+  before(:all) do
+    @data = Munger::Data.new(:data => test_data)
+  end
+
+  it "must accept a hash with symbols" do
+    hash = {'key1' => 'value1', 'key2' => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item.key1.must_equal('value1')
+  end
+
+  it "must accept a hash with strings" do
+    hash = {:key1 => 'value1', :key2 => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item.key1.must_equal('value1')
+    item.key2.wont_equal('value1')
+    item.key3.must_equal(nil)
+  end
+
+  it "must accept mixed types" do
+    hash = {:key1 => 'value1', 'key2' => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item.key1.must_equal('value1')
+    item.key2.must_equal('value2')
+  end
+
+  it "must be able to access hash values indifferently" do
+    hash = {:key1 => 'value1', 'key2' => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item['key1'].must_equal('value1')
+    item[:key2].must_equal('value2')
+  end
+
+  it "must return a hash after being initialized with a hash" do
+    hash = {:key1 => "value1", :key2 => "value2"}
+    Munger::Item.ensure(hash).to_hash.must_be_kind_of(Hash)
+  end
+
+end

data/{spec/munger/data/new_spec.rb → test/munger/new_test.rb}

@@ -1,18 +1,18 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require "test_helper"
 
 describe Munger::Data do
-  
+
   describe '.new' do
-    
+
     it 'initializes the data attribute to the :data value' do
       data = [{:foo => '1'}, {:foo => 2}]
-      Munger::Data.new(:data => data).data.should == data
+      Munger::Data.new(:data => data).data.must_equal(data)
     end
-    
+
     it 'yields itself to the given block' do
-      Munger::Data.new { |data| data.should be_kind_of(Munger::Data) }
+      Munger::Data.new { |data| data.must_be_kind_of(Munger::Data) }
     end
-    
+
   end
-  
-end
+
+end

data/test/munger/render_test.rb

@@ -0,0 +1,37 @@
+require "test_helper"
+
+describe Munger::Render do
+  include MungerSpecHelper
+
+  before(:each) do
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data).process
+  end
+
+  it "must render html" do
+    html = Munger::Render.to_html(@report)
+    html.must_have_tag('table')
+  end
+
+  it "must render sortable html" do
+    html = Munger::Render.to_sortable_html(@report, :sort => "name", :order => "asc", :url => "test")
+    html.must_have_tag("table")
+    html.must_have_tag("th.unsorted")
+    html.must_have_tag("th.sorted")
+    html.must_have_tag("th.sorted-asc")
+    html.must_have_tag("sort")
+  end
+
+  it "must render text" do
+    text = Munger::Render.to_text(@report)
+    text.wont_have_tag('table')
+    text.split("\n").length.must_be :>=, 5
+  end
+
+  it "must render xls"
+
+  it "must render csv"
+
+  it "must render pdf"
+
+end

data/test/munger/report_test.rb

@@ -0,0 +1,156 @@
+require "test_helper"
+
+describe Munger::Report do
+  include MungerSpecHelper
+
+  before(:each) do
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data)
+  end
+
+  it "must accept a Munger::Data object" do
+    Munger::Report.new(:data => @data).must_be :valid?
+  end
+
+  it "must accept a array of hashes" do
+    Munger::Report.new(:data => test_data).must_be :valid?
+    Munger::Report.new(:data => invalid_test_data).wont_be :valid?
+  end
+
+  it "must be able to sort fields by array" do
+    @report.sort = 'name'
+    data = @report.process.process_data
+    data.map { |a| a[:data].name }[0, 4].join(',').must_equal('Alice,Alice,Alice,Chaz')
+
+    @report.sort = ['name', 'age']
+    data = @report.process.process_data
+    data.map { |a| a[:data].age }[0, 4].join(',').must_equal('33,33,34,28')
+
+    @report.sort = [['name', :asc], ['age', :desc]]
+    data = @report.process.process_data
+    data.map { |a| a[:data].age }[0, 4].join(',').must_equal('34,33,33,28')
+  end
+
+  it "must be able to custom sort fields" do
+    @report.sort = [['name', Proc.new {|a, b| a[2] <=> b[2]} ]]
+    data = @report.process.process_data
+    data.map { |a| a[:data].name }[0, 4].join(',').must_equal('Chaz,Rich,Alice,Alice')
+  end
+
+  it "must be able to order columns" do
+    @report.columns([:name, :age, :score])
+    @report.columns.must_equal([:name, :age, :score])
+  end
+
+  it "must be able to alias column titles" do
+    titles = {:name => 'My Name', :age => 'The Age', :score => 'Super Score'}
+    @report.column_titles = titles
+    @report.column_titles.must_equal(titles)
+  end
+
+  it "must default to all columns" do
+    @report.columns.map { |c| c.to_s }.sort.join(',').must_equal('age,day,name,score')
+  end
+
+
+  it "must be able to subgroup data" do
+    @report.sort('name').subgroup('name').process
+    @report.get_subgroup_rows.size.must_equal(6)
+  end
+
+  it "must be able to add subgroup headers"
+  #  do
+  #   @report.sort('score').subgroup('score', :with_headers => true)
+  #   @report.aggregate(:sum => :score).process
+  #   puts Munger::Render.to_text(@report)
+  # end
+
+  it "must add the grouping name on the group line somewhere"
+
+  it "must be able to subgroup in multiple dimensions"
+
+  it "must be able to aggregate columns into subgroup rows" do
+    @report.sort('name').subgroup('name').aggregate(:sum => :score).process
+    @report.get_subgroup_rows(1).size.must_equal(6)
+    @report.get_subgroup_rows(0).size.must_equal(1)
+    @report.get_subgroup_rows(0).first[:data][:score].must_equal(151)
+  end
+
+  it "must be able to aggregate multiple columns into subgroup rows" do
+    @report.sort('name').subgroup('name').aggregate(:sum => [:score, :age]).process
+    data = @report.get_subgroup_rows(0).first[:data]
+    data[:score].must_equal(151)
+    data[:age].must_equal(294)
+
+    @report.sort('name').subgroup('name').aggregate(:sum => :score, :average => :age).process
+    data = @report.get_subgroup_rows(0).first[:data]
+    data[:score].must_equal(151)
+    data[:age].must_equal(29)
+  end
+
+  it "must be able to aggregate with :average" do
+    @report.sort('name').subgroup('name').aggregate(:average => :score).process
+    @report.get_subgroup_rows(0).first[:data][:score].must_equal(15)
+  end
+
+  it "must be able to aggregate with :custom" do
+    @report.sort('name').subgroup('name')
+    @report.aggregate(Proc.new { |d| d.inject { |t, a| 2 * (t + a) } } => :score).process
+    @report.get_subgroup_rows(0).first[:data][:score].must_equal(19508)
+  end
+
+  it "must be able to style cells" do
+    @report.process
+    @report.style_cells('highlight') { |c, r| c == 32 }
+    styles = @report.process_data.select { |r| r[:meta][:cell_styles] }
+    styles.size.must_equal(2)
+  end
+
+  it "must be able to style cells in certain columns" do
+    @report.process
+    @report.style_cells('highlight', :only => :age) { |c, r| c == 32 }
+    @report.style_cells('big', :except => [:name, :day]) { |c, r| c.size > 2 }
+    styles = @report.process_data.select { |r| r[:meta][:cell_styles] }
+    styles.size.must_equal(10)
+
+    janet = @report.process_data.select { |r| r[:data].name == 'Janet' }.first
+    jstyles = janet[:meta][:cell_styles]
+
+    jstyles[:age].sort.join(',').must_equal('big,highlight')
+    jstyles[:score].must_equal(["big"])
+  end
+
+  it "must be able to style rows" do
+    @report.process
+    @report.style_rows('over_thirty') { |row| row.age > 29 }
+    @report.style_cells('highlight', :only => :age) { |c, r| c == 32 }
+
+    janet = @report.process_data.select { |r| r[:data].name == 'Janet' }.first[:meta]
+    janet[:row_styles].must_equal(["over_thirty"])
+    janet[:cell_styles].size.must_equal(1)
+    janet[:cell_styles][:age].must_equal(["highlight"])
+  end
+
+  it "must know when it is processed" do
+    @report.processed?.wont_equal(true)
+    @report.process
+    @report.processed?.must_equal(true)
+  end
+
+  it "must be able to style columns"
+
+  it "must be able to attach formatting independent of content"
+  # so can format numbers without hurting ability to aggregate correctly
+  # or add hyperlinks using data from columns not being shown
+
+  it "must be able to add and retrieve column formatters" do
+    @report.column_formatters = {:name => :to_s}
+    @report.process
+    @report.column_formatters.size.must_equal(1)
+    @report.column_formatter(:name).must_equal(:to_s)
+  end
+
+  it "must be able to aggregate rows into new column"
+
+
+end

data/{spec/munger/render/text_spec.rb → test/munger/text_test.rb}

@@ -1,22 +1,22 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
+require "test_helper"
 
-describe Munger::Render::Text do 
+describe Munger::Render::Text do
   include MungerSpecHelper
-  
-  before(:each) do 
+
+  before(:each) do
     @data = Munger::Data.new(:data => test_data)
     @report = Munger::Report.new(:data => @data)
   end
 
   it "should accept a Munger::Report object" do
-    Munger::Render::Text.new(@report.process).should be_valid
+    Munger::Render::Text.new(@report.process).must_be :valid?
   end
-  
+
   it "should render a basic text table" do
     @render = Munger::Render::Text.new(@report.process)
     count = @report.rows
     text = @render.render
-    text.split("\n").should have_at_least(count).items
+    text.split("\n").size.must_be :>, count
   end
-  
-end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,60 @@
+require "minitest/autorun"
+require "minitest/pride"
+require "munger"
+
+require "fileutils"
+require "logger"
+require "pp"
+require "date"
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+module MungerSpecHelper
+  def test_data
+    [{:name => "Scott", :age => 23, :day => 1, :score => 12},
+     {:name => "Chaz",  :age => 28, :day => 1, :score => 12},
+     {:name => "Scott", :age => 23, :day => 2, :score => 1},
+     {:name => "Janet", :age => 32, :day => 2, :score => 24},
+     {:name => "Rich", :age => 32, :day => 2, :score => 14},
+     {:name => "Gordon", :age => 33, :day => 1, :score => 21},
+     {:name => "Scott", :age => 23, :day => 1, :score => 31},
+     {:name => "Alice", :age => 33, :day => 1, :score => 12},
+     {:name => "Alice", :age => 34, :day => 2, :score => 12},
+     {:name => "Alice", :age => 33, :day => 2, :score => 12}
+      ]
+  end
+
+  def more_test_data
+    [{:name => "David", :age => 40, :day => 1, :score => 12},
+     {:name => "Michael",  :age => 32, :day => 2, :score => 20},
+     {:name => "David", :age => 40, :day => 2, :score => 13},
+     {:name => "Michael",  :age => 28, :day => 1, :score => 15}]
+  end
+
+  def invalid_test_data
+    ["one", "two", "three"]
+  end
+
+  def test_ar_data
+    test_data.map{|r| ARLike.new(r)}
+  end
+
+end
+
+# Hack to provide assertion for tags without needing
+# hpricot or Nokogiri
+module Minitest::Assertions
+  def assert_has_tag(tag, html, options = {})
+    tag = tag.split(".").join("|") if tag.include?(".")
+    # ignore options for now
+    assert html.match(/#{tag}/)
+  end
+
+  def refute_has_tag(tag, html, options = {})
+    refute html.match(/#{tag}/)
+  end
+end
+
+String.infect_an_assertion :assert_has_tag, :must_have_tag
+String.infect_an_assertion :refute_has_tag, :wont_have_tag