google_data_source 0.7.6

data/test/units/csv_data_test.rb

@@ -0,0 +1,36 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class CvsDataTest < ActiveSupport::TestCase
+  def setup
+    setup_db
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  test "csv rendering" do
+    items = [Item.create(:name => "Item Name", :description => "description", :number => 0)]
+    ds = GoogleDataSource::DataSource::Base.from_params({:tqx => "reqId:0;out:csv"})
+
+    columns = [
+      {:id => 'name', :label => 'Name', :type => 'string'},
+      {:id => 'number', :label => 'Number', :type => 'number'},
+    ]
+    ds.set(items, columns)
+
+    result = CSV.parse(ds.response, :col_sep => ';')
+    assert_equal [["Name", "Number"], ["Item Name", "0"]], result
+  end
+
+  test "number formating" do
+    items = [{:int => 1000000, :float => 1000000000.1}]
+    ds = GoogleDataSource::DataSource::Base.from_params({:tqx => "reqId:0;out:csv"})
+    columns = [
+      {:id => 'int', :type => 'number'},
+      {:id => 'float', :type => 'number'},
+    ]
+    ds.set(items, columns)
+    #TODO
+  end
+end

data/test/units/grouped_set_test.rb

@@ -0,0 +1,60 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class GroupedSetTest < ActiveSupport::TestCase
+  class TestReportingEntry < ReportingEntry
+    SUMMABLE_INT_FIELDS_REGEXP   = /^(views|clicks|backfill_views|.*transaction_count)$/
+    SUMMABLE_FLOAT_FIELDS_REGEXP = /^(.*_sum|.*_sum_after_share)$/
+    NOT_SUMMABLE_FIELDS          = %w(public_website_name)
+  end
+  
+  setup do
+    entries = []
+    entries << TestReportingEntry.new({:date => Date.today.to_s(:db), :unit_id => "1", :ad_id => "1", :open_sum => "1" })
+    entries << TestReportingEntry.new({:date => Date.today.to_s(:db), :unit_id => "2", :ad_id => "1", :open_sum => "2" })
+    entries << TestReportingEntry.new({:date => Date.today.to_s(:db), :unit_id => "1", :ad_id => "2", :open_sum => "4" })
+    entries << TestReportingEntry.new({:date => Date.today.to_s(:db), :unit_id => "2", :ad_id => "2", :open_sum => "8" })
+    entries << TestReportingEntry.new({:date => 1.day.ago.to_s(:db),  :unit_id => "1", :ad_id => "1", :open_sum => "16" })
+
+    @set = GroupedSet.new(entries)
+  end
+
+  test "should group by single key" do
+    data = @set.regroup(:date)
+    assert_equal 2, data.size
+    todays_entry = data.select { |e| e.date == Date.today.to_s(:db) }.first
+    assert_equal 15.0, todays_entry.open_sum
+  end
+
+  test "should group by multiple keys" do
+    data = @set.regroup(:date, :ad_id)
+    assert_equal 3, data.size
+    todays_ad1_entry = data.select { |e| e.date == Date.today.to_s(:db) && e.ad_id == "1"}.first
+    assert_equal 3.0, todays_ad1_entry.open_sum
+  end
+
+  test "should group by block" do
+    data = @set.regroup { |e| e.date }
+    assert_equal 2, data.size
+    todays_entry = data.select { |e| e.date == Date.today.to_s(:db) }.first
+    assert_equal 15.0, todays_entry.open_sum
+  end
+
+  test "should collapse" do
+    data = @set.collapse
+    assert_equal 31.0, data.open_sum
+  end
+  
+  test "something interesting" do
+    result = [
+              {"campaign_name"=>"Campaign #5", "billing_subject"=>'foo', "campaign_id"=>"8188", "transaction_count"=>"2", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"45.3000001907349", "status"=>"confirmed", "pricing_association_id"=>"330"}, 
+              {"campaign_name"=>"Campaign #6", "billing_subject"=>'blah', "campaign_id"=>"8189", "transaction_count"=>"1", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"1.10000002384186", "status"=>"confirmed", "pricing_association_id"=>"330"}, 
+              {"campaign_name"=>"Campaign #6", "billing_subject"=>'blah', "campaign_id"=>"8189", "transaction_count"=>"1", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"1.10000002384186", "status"=>"open", "pricing_association_id"=>"330"}, 
+              {"campaign_name"=>"Campaign #6", "billing_subject"=>"test", "campaign_id"=>"8189", "transaction_count"=>"1", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"31337", "status"=>"open", "pricing_association_id"=>"330"}
+            ]
+    result.collect!{ |re| TestReportingEntry.new(re) }
+    result = GroupedSet.new(result)
+    result = result.regroup('campaign_id', 'billing_subject')
+    assert_equal %w(foo blah test), result.collect(&:billing_subject)
+    assert_equal 3, result.size
+  end
+end

data/test/units/json_data_test.rb

@@ -0,0 +1,68 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class JsonDataTest < ActiveSupport::TestCase
+  context 'The JSON Data output engine' do
+    setup do
+      setup_db
+    end
+    
+    teardown do
+      teardown_db
+    end
+    
+    setup do
+      @items = [
+        Item.create(
+          :name => "Item Name", 
+          :description => "description", 
+          :number      => 0,
+          :date        => '2011-01-01',
+          :datetime     => '2011-01-01 23:59:59'
+        ),
+        Item.create(
+          :name => "Item Name", 
+          :description => "description", 
+          :number      => 10,
+          :date        => nil,
+          :datetime     => nil
+        )
+      ]
+      @datasource = GoogleDataSource::DataSource::Base.from_params({:tqx => "reqId:0;out:json"})
+
+      @columns = [
+        {:id => 'name', :label => 'Name', :type => 'string'},
+        {:id => 'number', :label => 'Number', :type => 'number'},
+        {:id => 'date', :label => 'Date', :type => 'date'},
+        {:id => 'datetime', :label => 'Datetime', :type => 'datetime'},
+      ]
+      @datasource.set(@items, @columns)
+      @raw_json = @datasource.response.match(/\{(.*)\}/)[0].gsub("\\\\", "\\");
+      @json = JSON.parse(@raw_json)
+    end
+    
+    should "correctly render a json record" do
+      assert_equal 'Item Name', @json['table']['rows'].first.first.last[0]['v']
+    end
+
+    should "render an integer" do
+      assert_equal 0, @json['table']['rows'].first.first.last[1]['v']
+      assert_equal 10, @json['table']['rows'].last.first.last[1]['v']
+    end
+    
+    should "correctly render a datetime value" do
+      assert_equal 'Date(2011, 0, 1, 23, 59, 59)', @json['table']['rows'].first.first.last[3]['v']
+    end
+    
+    should "corretly render an empty datetime" do
+      assert_equal nil, @json['table']['rows'].last.first.last[3]['v']
+    end
+    
+    should "correctly render a date value" do
+      assert_equal 'Date(2011, 0, 1)', @json['table']['rows'].first.first.last[2]['v']
+    end
+    
+    should "corretly render an empty date" do
+      assert_equal nil, @json['table']['rows'].last.first.last[3]['v']
+    end
+  end
+end

data/test/units/reporting_adapter_test.rb

@@ -0,0 +1,20 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class ReportingAdapterTest < ActiveSupport::TestCase
+  setup do
+    @adapter = ActiveRecord::ConnectionAdapters::ReportingAdapter.new
+  end
+  
+  test "quote a single quote with a backslash" do
+    assert_equal "'foo\\''", @adapter.quote('foo\'')
+  end
+  
+  test "return integers as quoted boolean" do
+    assert_equal "'1'", @adapter.quoted_true
+    assert_equal "'0'", @adapter.quoted_false
+  end
+  
+  test "quote a backslash with a backslash" do
+    assert_equal "'foo\\\\'", @adapter.quote("foo\\")
+  end
+end

data/test/units/reporting_entry_test.rb

@@ -0,0 +1,149 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class ReportingEntryTest < ActiveSupport::TestCase
+  class TestReportingEntry < ReportingEntry
+    SUMMABLE_INT_FIELDS_REGEXP    = /int|another_value/
+    SUMMABLE_FLOAT_FIELDS_REGEXP  = /float/
+    NOT_SUMMABLE_FIELDS           = %w(hide_me)
+
+    def reduced
+      int - 1
+    end
+
+    def another_value
+      return 1
+    end
+    
+    def hide_me
+      "I'm not shown in sum entry"
+    end
+    
+    def show_me
+      "I'm shown!"
+    end
+  end
+
+  def setup
+  end
+
+  test "OpenStrcut like access" do
+    entry = TestReportingEntry.new(:foo => 'bar')
+    assert_equal 'bar', entry.foo
+  end
+
+  test "NoMethodError when attribute is not set" do
+    entry = TestReportingEntry.new()
+    assert_raise NoMethodError do
+      entry.foo
+    end
+  end
+
+  test "int values casting" do
+    entry = TestReportingEntry.new(:int => "1")
+    assert_equal 1, entry.int
+    assert entry.int.is_a?(Integer)
+  end
+
+  test "float values casting" do
+    entry = TestReportingEntry.new(:float => "1.5")
+    assert_equal 1.5, entry.float
+    assert entry.float.is_a?(Float)
+  end
+
+  test "accessors for numeric values should return 0 if the values are not defined" do
+    entry = TestReportingEntry.new
+    assert_equal 0, entry.int
+    assert_equal 0.0, entry.float
+  end
+
+  test "the + method should add up all numeric values while merging all others" do
+    entry1 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    entry2 = TestReportingEntry.new(:int => 2, :float => 2.5, :foo => 'bar')
+    sum = entry1 + entry2
+
+    assert_equal 3,     sum.int
+    assert_equal 4.0,   sum.float
+    assert_equal 'bar', sum.foo
+  end
+
+  test "the composite entry should also support a working + method" do
+    entry1 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    entry2 = TestReportingEntry.new(:int => 2, :float => 2.5, :foo => 'bar')
+    entry3 = TestReportingEntry.new(:int => 3, :float => 3.5, :foo => 'bar')
+    sum = entry1 + entry2 + entry3
+
+    assert_equal 6, sum.int
+    assert_equal 7.5, sum.float
+  end
+
+  test "virtual attributes should also work an composite entries" do
+    entry1 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    entry2 = TestReportingEntry.new(:int => 2, :float => 2.5, :foo => 'bar')
+
+    assert_equal 0, entry1.reduced
+    sum = entry1 + entry2
+    assert_equal 2, sum.reduced
+  end
+
+  test "to_sum_entry should only set numerical values and strip all others" do
+    entry = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    sum_entry = entry.to_sum_entry
+
+    assert_nil sum_entry.foo
+    assert_equal 1, sum_entry.int
+    assert_equal 1.5, sum_entry.float
+  end
+
+  test "to_sum_entry on composite entries" do
+    entry1 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    entry2 = TestReportingEntry.new(:int => 2, :float => 2.5, :foo => 'bar')
+    sum = (entry1 + entry2).to_sum_entry
+
+    assert_nil sum.foo
+    assert_equal 3, sum.int
+  end
+  
+  test 'to_sum_entry should not return any explicitely hidden ruby columns' do
+    entry1 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    entry2 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    assert_equal nil, (entry1 + entry2).to_sum_entry.hide_me
+  end
+
+  test 'to_sum_entry should return all ruby columns in sum entry by default' do
+    entry1 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    entry2 = TestReportingEntry.new(:int => 1, :float => 1.5, :foo => 'bar')
+    assert_equal "I'm shown!", (entry1 + entry2).to_sum_entry.show_me
+  end
+
+  test "handle summable virtual attributes correclty" do
+    entry1 = TestReportingEntry.new()
+    entry2 = TestReportingEntry.new()
+    sum = entry1 + entry2
+
+    assert_equal 1, entry1.another_value
+    assert_equal 2, sum.another_value
+  end
+  
+  test "be able to group by billing_subject" do
+    result = [
+              {"campaign_name"=>"Campaign #5", "billing_subject"=>'foo', "campaign_id"=>"8188", "transaction_count"=>"2", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"45.3000001907349", "status"=>"confirmed", "pricing_association_id"=>"330"}, 
+              {"campaign_name"=>"Campaign #6", "billing_subject"=>'blah', "campaign_id"=>"8189", "transaction_count"=>"1", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"1.10000002384186", "status"=>"confirmed", "pricing_association_id"=>"330"}, 
+              {"campaign_name"=>"Campaign #6", "billing_subject"=>'blah', "campaign_id"=>"8189", "transaction_count"=>"1", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"1.10000002384186", "status"=>"open", "pricing_association_id"=>"330"}, 
+              {"campaign_name"=>"Campaign #6", "billing_subject"=>"test", "campaign_id"=>"8189", "transaction_count"=>"1", "postview_transaction_count"=>"0", "click_transaction_count"=>"0", "sum"=>"31337", "status"=>"open", "pricing_association_id"=>"330"}
+            ]
+    result.collect!{ |re| ReportingEntry.new(re) }
+    result = result.group_by { |entry| "#{entry.send(:billing_subject)}" }.values
+    assert_equal 3, result.size
+    
+    result = result.collect do |entries|
+      # Uses the class of the first element to build the composite element
+      entries.first.class.composite(entries)
+    end
+    
+    assert_equal %w(foo blah test), result.collect(&:billing_subject)
+  end
+  
+  test "virtual attributes " do
+    assert true
+  end
+end

data/test/units/reporting_test.rb

@@ -0,0 +1,374 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+require "test_reporting"
+require "test_reporting_b"
+require "test_reporting_c"
+require "empty_reporting"
+
+class ReportingTest < ActiveSupport::TestCase
+  def setup
+    @reporting = TestReporting.new
+  end
+  
+  test "should return the columns hash, activerecord like" do
+    columns_hash = TestReporting.columns_hash
+    assert columns_hash.kind_of?(Hash), 'should be a hash'
+    assert_equal 'name', columns_hash.keys.first
+  end
+  
+  test 'should return all column names' do
+    columns = ["name", "age", "address", "fullname", "fullfullname", "circle_a", "circle_b", "from_date", "to_date", "in_foo"]
+    assert_equal columns, TestReporting.column_names
+  end
+  
+  test "should be able to use the accessors as expected" do
+    @reporting.name = 'test'
+    assert_equal 'test', @reporting.name
+  end
+  
+  test "should return a hash with all default values" do
+    defaults = TestReporting.column_defaults
+    assert_equal 'foobar', defaults['name'], 'has a default value for name'
+    assert_equal nil, defaults['age'], 'has no default value for age'
+  end
+  
+  test "rows should call aggregate once and only once" do
+    @reporting.data
+    @reporting.data
+    assert_equal 1, @reporting.aggregate_calls
+  end
+  
+  test "should return true if the object is filterable through given column" do
+    assert ! @reporting.filterable_by?(:age), 'should not be filterable by normal columns'
+    assert @reporting.filterable_by?(:name), 'should be filterable even if the filter was defined as column before'
+    assert @reporting.filterable_by?(:from_date), 'should be filterable'
+    assert @reporting.filterable_by?('from_date'), 'should be filterable even if a string is given'
+  end
+  
+  test "should have a seperate hash for filters" do
+    assert_equal({ :type => :string, :default => 'foobar' }, 
+      @reporting.class.datasource_filters["name"],
+      'should be filterable by name')
+  end
+  
+  test "from_params should typecast a date correctly" do
+    query = "where name = 'test name' and from_date = '2010-01-01'"
+    r = TestReporting.from_params({:tq => query})
+    assert_equal "test name", r.name
+    assert_equal "2010-01-01".to_date, r.from_date
+  end
+  
+  test "select default value" do
+    r = TestReporting.new
+    assert_equal %w(name age), r.select
+  end
+  
+  test "group by default value" do
+    r = TestReporting.new
+    assert_equal %w(name), r.group_by
+  end
+  
+  test "limit by default value" do
+    r = TestReporting.new
+    assert_equal 1000, r.limit
+  
+    r = TestReporting.new(:limit => 5)
+    assert_equal 5, r.limit
+  
+    r = TestReporting.new(:limit => "10")
+    assert_equal 10, r.limit
+  end
+  
+  test "from_params should set select" do
+    query = "select name"
+    r = TestReporting.from_params({:tq => query})
+    assert_equal ['name'], r.select
+  end
+  
+  test "select should explode a * column" do
+    query = "select *"
+    r = TestReporting.from_params({:tq => query})
+    r.add_virtual_column(:virtual)
+  
+    select = %w(name age address fullname fullfullname circle_a circle_b virtual)
+    assert_equal select, r.select
+  end
+  
+  test "from_parmas should set group_by" do
+    query = "select name group by name"
+    r = TestReporting.from_params({:tq => query})
+    assert_equal ['name'], r.group_by
+  end
+  
+  test 'should return groupable columns' do
+    reporting = TestReporting.new
+    assert_equal [ :age, :address ], reporting.groupable_columns
+  end
+  
+  test "from_params should also take regular get parameters (not the query) into account" do
+    params = HashWithIndifferentAccess.new({:tq => '', :test_reporting => {:name => 'John'}})
+    r = TestReporting.from_params(params, 'test_reporting')
+    assert_equal "John", r.name
+  end
+  
+  test "from_params should also take regular get parameters into account (with custom param name)" do
+    params = HashWithIndifferentAccess.new({:tq => '', :reporting => {:name => 'John'}})
+    r = TestReporting.from_params(params, :reporting)
+    assert_equal "John", r.name
+  end
+  
+  test "from_params_with_date_range" do
+    query = "where `date` >= '2010-01-01' and `date`<='2010-02-01'"
+    r = TestReporting.from_params({:tq => query})
+    assert_equal "2010-01-01".to_date, r.from_date
+    assert_equal "2010-02-01".to_date, r.to_date
+  end
+  
+  test "setting datasource columns" do
+    assert_equal :string, @reporting.datasource_columns['name'][:type]
+    assert_equal :string, TestReporting.datasource_columns['name'][:type]
+  end
+  
+  test "get column definitions with respect to custom column labels and select" do
+    columns = @reporting.columns
+    assert_equal 2,       columns.size
+    assert_equal 'name',  columns[0][:id]
+    assert_equal :string, columns[0][:type]
+  end
+  
+  test "different subclasses can have different sets of columns" do
+    assert TestReporting.datasource_columns != TestReportingB.datasource_columns
+  end
+  
+  test "different subclasses can have different default selects and groupings" do
+    a = TestReporting.new
+    b = TestReportingB.new
+    assert a.group_by != b.group_by
+    assert a.select != b.select
+  end
+  
+  test "sublasses should inherit all columns" do
+    reporting = TestReportingB.new
+    assert_nothing_raised do
+      assert reporting.datasource_columns.include?('name')
+      assert reporting.datasource_columns.include?('name_b')
+    end
+  end
+  
+  test "subclasses should inherit all filters" do
+    assert_equal 5, TestReportingB.datasource_filters.count
+  end
+  
+  test "subclasses should inherit all defaults" do
+    reporting = TestReportingC.new
+    assert_nothing_raised do
+      assert_equal ["name", "age"], reporting.defaults[:select]
+    end
+  end
+  
+  test "should set limit and offset in from_params" do
+    reporting = TestReporting.from_params(:tq => "limit 10 offset 5")
+    assert_equal 10, reporting.limit
+    assert_equal 5, reporting.offset
+    reporting = TestReporting.from_params("query" => { "limit" => "10", "offset" => "5" })
+    assert_equal 10, reporting.limit
+    assert_equal 5, reporting.offset
+  end
+  
+  test "should set the order_by attribute in from_params" do
+    reporting = TestReporting.from_params(:tq => "order by name")
+    assert_equal ['name', :asc], reporting.order_by
+  end
+  
+  test "should return nil for order by and offset if not set" do
+    reporting = TestReporting.new
+    assert_nil reporting.order_by
+    #assert_nil reporting.limit
+    assert_nil reporting.offset
+  end
+  
+  test "parse in( ) statement and put in 'in_xxx' attribute" do
+    reporting = TestReporting.from_params(:tq => "where foo in (1, 2)")
+    assert_equal %w(1 2), reporting.in_foo
+  end
+  
+  test "translation of column labels" do
+    assert_equal 'AgeReportings', @reporting.column_label(:age)
+    assert_equal 'AddressModels', @reporting.column_label(:address)
+  end
+  
+  test "the rows method should accept a reqired_columns option" do
+    @reporting.select   = %w(age)
+    @reporting.group_by = []
+    assert_equal %w(age), @reporting.required_columns
+    @reporting.data(:required_columns => %w(name))
+    assert_equal %w(age name), @reporting.required_columns
+  end
+  
+  test "serialization and deserialization" do
+    @reporting.select   = %w(age)
+    @reporting.group_by = %w(age)
+    @reporting.order_by = %w(name)
+    @reporting.limit    = 10
+    @reporting.offset   = 20
+    @reporting.name     = "John"
+  
+    serialized = @reporting.serialize
+    reporting = TestReporting.deserialize(serialized)
+  
+    assert_equal @reporting.select, reporting.select
+    assert_equal @reporting.group_by, reporting.group_by
+    assert_equal @reporting.order_by, reporting.order_by
+    assert_equal @reporting.limit, reporting.limit
+    assert_equal @reporting.offset, reporting.offset
+    assert_equal @reporting.name, reporting.name
+  end
+  
+  test "from_params should recognize a serialized object and deserialize it" do
+    @reporting.select   = %w(age)
+    @reporting.group_by = %w(age)
+    @reporting.name     = "John"
+    serialized = @reporting.serialize
+    reporting = TestReporting.from_params(@reporting.to_params)
+  
+    assert_equal @reporting.select, reporting.select
+    assert_equal @reporting.group_by, reporting.group_by
+    assert_equal @reporting.name, reporting.name
+  end
+  
+  test 'from_params should accept a hash without a module name' do
+    reporting = TestReporting.from_params('test_reporting' => { 'select' => %w(age) })
+    assert_equal %w(age), reporting.select
+  end
+  
+  test 'from_params from param "query" should work as well' do
+    reporting = TestReporting.from_params('query' => { 'name' => 'bla' })
+    assert_equal 'bla', reporting.name
+  end
+  
+  test 'accept a "page" param and calculate the offset' do
+    reporting = TestReporting.from_params('query' => { 'page' => '3' })
+    assert reporting.limit.is_a?(Integer)
+    assert reporting.offset.is_a?(Integer)
+    assert_equal reporting.limit * 2, reporting.offset
+  end
+  
+  test 'to_params should export the hash with a module name by default' do
+    assert_equal %w(test_reporting), @reporting.to_params.keys
+  end
+  
+  test "initialize should handle date string with grace" do
+    reporting = TestReporting.new(:from_date => '2010-01-01')
+    assert_equal Date.parse('2010-01-01'), reporting.from_date
+  end
+  
+  test "account for the 'requires' option in column definition" do
+    reporting = TestReporting.new
+    reporting.select   = %w(fullname)
+    reporting.group_by = []
+    result = reporting.required_columns
+    assert_equal 2, result.size
+    assert result.include?('name')
+    assert result.include?('fullname')
+  end
+  
+  test "'requires' option in column definition should work recursivly" do
+    reporting = TestReporting.new
+    reporting.select   = %w(fullfullname)
+    reporting.group_by = []
+    result = reporting.required_columns
+    assert_equal 3, result.size
+    assert result.include?('name')
+    assert result.include?('fullname')
+    assert result.include?('fullfullname')
+  end
+  
+  test "recognize circle dependencies in column and throw exception" do
+    reporting = TestReporting.new
+    reporting.select   = %w(circle_a)
+    reporting.group_by = []
+    assert_raise CircularDependencyException do
+      reporting.required_columns
+    end
+  end
+  
+  test "required_columns should handle virtual columns with grace" do
+    reporting = TestReporting.new
+    reporting.select = %w(virtual_column name)
+    assert_equal %w(virtual_column name), reporting.required_columns
+  end
+  
+  ################################
+  # Test ActiveRecord extension
+  ################################
+  
+  test "class loads" do
+    assert_nothing_raised { Reporting }
+  end
+  
+  test "can add columns" do
+    self.class.class_eval %q{
+      class CanAddColumns < Reporting
+        %w(foo bar test).each { |c| column c }
+      end
+    }
+    assert_equal 3, CanAddColumns.columns.size
+  end
+  
+  test "type properly set" do
+    self.class.class_eval %q{
+      class TypeProperlySet < Reporting
+        %w(string text date datetime boolean).each do |type|
+          filter "a_#{type}".to_sym, :type => type.to_sym
+        end
+      end
+    }
+    
+    assert TypeProperlySet.columns.size > 0, 'no filters added'
+    
+    %w(string text date datetime boolean).each do |type|
+      assert_equal type, TypeProperlySet.columns_hash["a_#{type}"].sql_type
+    end
+  end
+  
+  test "default properly set" do
+    self.class.class_eval %q{
+      class DefaultPropertlySet < Reporting
+        filter :bicycle, :default => 'batavus'
+      end
+    }
+    assert_equal 'batavus', DefaultPropertlySet.new.bicycle
+  end
+  
+  test "columns are humanizable" do
+    self.class.class_eval %q{
+      class Humanizable < Reporting
+        filter :bicycle, :human_name => 'fiets'
+      end
+    }
+    
+    assert_equal 'fiets', Humanizable.columns_hash['bicycle'].humanize
+  end
+  
+  test "create gbang raises no exception on valid" do
+    self.class.class_eval %q{
+      class CreateBangSuccess < Reporting; end
+    }
+    
+    assert_nothing_raised do
+      CreateBangSuccess.create!
+    end
+  end
+  
+  test "create bang raises exception on invalid" do
+    self.class.class_eval %q{
+      class CreateBangFailure < Reporting
+        filter :required_field
+        validates_presence_of :required_field
+      end
+    }
+    
+    assert_raises ActiveRecord::RecordInvalid do
+      CreateBangFailure.create!
+    end
+  end
+end