report_cat 0.2.0

data/spec/lib/report_cat/core/column_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+include ReportCat::Core
+
+module ReportCat::Core
+
+  describe Column do
+
+    before( :each ) do
+      @name = :test
+      @type = :select
+      @options = { :sql => 'max( something )' }
+    end
+
+    #############################################################################
+    # #initialize
+
+    describe '#initialize' do
+
+      it 'initializes accessor values' do
+        column = Column.new( :name => @name, :type => @type, :options => @options )
+        expect( column.name ).to eql( @name )
+        expect( column.type ).to eql( @type )
+        expect( column.options ).to eql( @options )
+      end
+
+    end
+
+    #############################################################################
+    # #format
+
+    describe '#format' do
+
+      it 'formats floats' do
+        value = 22.0 / 7.0
+        expected = ("%.2f" % value).to_f
+        column = Column.new( :name => @name, :type => :float )
+        expect( column.format( value ) ).to eql( expected )
+      end
+
+
+      it 'formats integers' do
+        value = '727'
+        expected = value.to_i
+        column = Column.new( :name => @name, :type => :integer )
+        expect( column.format( value ) ).to eql( expected )
+
+      end
+
+      it 'passes everything else through' do
+        value = '727'
+        column = Column.new( :name => @name, :type => :string )
+        expect( column.format( value ) ).to eql( value )
+      end
+
+    end
+
+    #############################################################################
+    # #post_process
+
+    describe '#post_process' do
+
+      before( :each ) do
+        @report = Report.new
+      end
+
+      it 'handles moving averages' do
+        column = Column.new( :name => @name, :type => :moving_average )
+        expect( column ).to receive( :post_process_moving_average ).with( @report )
+        column.post_process( @report )
+      end
+
+      it 'handles ratios' do
+        column = Column.new( :name => @name, :type => :ratio )
+        expect( column ).to receive( :post_process_ratio ).with( @report )
+        column.post_process( @report )
+      end
+
+    end
+
+    #############################################################################
+    # #post_process_moving_average
+
+    describe '#post_process_moving_average' do
+
+      it 'fills in moving average values' do
+        @report = Report.new
+        @report.add_column( :value, :integer )
+
+        @report.rows[ 0 ] =  [ 1, 0 ]
+        @report.rows[ 1 ] =  [ 2, 0 ]
+        @report.rows[ 2 ] =  [ 4, 0 ]
+
+        column =  @report.add_column( :ma, :moving_average, :target => :value, :interval => 2 )
+        column.post_process( @report )
+
+        expect( @report.rows[ 0 ][ 1 ] ).to eql( 0 )
+        expect( @report.rows[ 1 ][ 1 ] ).to eql( 1.5 )
+        expect( @report.rows[ 2 ][ 1 ] ).to eql( 3.0 )
+      end
+
+    end
+
+    #############################################################################
+    # #post_process_moving_average
+
+    describe '#post_process_ratio' do
+
+      it 'fills in ratio values' do
+        @report = Report.new
+        @report.add_column( :n, :integer )
+        @report.add_column( :d, :integer )
+
+        @report.rows[ 0 ] =  [ 1, 2, 0 ]
+        @report.rows[ 1 ] =  [ 3, 4, 0 ]
+        @report.rows[ 2 ] =  [ 4, 0, 0 ]
+
+        column =  @report.add_column( :r, :ratio, :numerator => :n, :denominator => :d )
+        column.post_process( @report )
+
+        expect( @report.rows[ 0 ][ 2 ] ).to eql( 0.5 )
+        expect( @report.rows[ 1 ][ 2 ] ).to eql( 0.75 )
+        expect( @report.rows[ 2 ][ 2 ] ).to eql( 0.0 )
+      end
+
+    end
+
+    #############################################################################
+    # #to_sql
+
+    describe '#to_sql' do
+
+      it 'uses raw sql if provided in options' do
+        sql = 'count( id )'
+        column = Column.new( :name => @name, :type => :integer, :options => { :sql => sql } )
+        expect( column.to_sql ).to eql( "#{sql} as #{@name}" )
+      end
+
+
+      it 'uses 0 for calculated columns' do
+        column = Column.new( :name => @name, :type => :moving_average )
+        expect( column.to_sql ).to eql( "0 as #{@name}" )
+
+        column = Column.new( :name => @name, :type => :ratio )
+        expect( column.to_sql ).to eql( "0 as #{@name}" )
+      end
+
+      it 'uses the column name as a last resort' do
+        column = Column.new( :name => @name, :type => :integer )
+        expect( column.to_sql ).to eql( @name )
+      end
+
+    end
+
+  end
+end

data/spec/lib/report_cat/core/param_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+include ReportCat::Core
+
+module ReportCat::Core
+
+  describe Param do
+
+    let( :param ) { Param.new }
+
+    before( :each ) do
+      @name = :test
+      @type = :select
+      @value = 727
+      @options = [ 314, 727 ]
+    end
+
+    describe 'initialize' do
+
+      it 'initializes accessor values' do
+        param = Param.new( :name => @name, :type => @type, :value => @value, :options => @options )
+        expect( param.name ).to eql( @name )
+        expect( param.type ).to eql( @type )
+        expect( param.value ).to eql( @value )
+        expect( param.options ).to eql( @options )
+      end
+
+      it 'initializes options to an empty hash' do
+        expect( param.options ).to eql( {} )
+      end
+
+    end
+
+    describe 'assigning value' do
+
+      it 'turns checkboxes into booleans' do
+        param = Param.new( :name => :foo, :type => :check_box )
+        expect( param.value ).to be_nil
+        param.value = '1'
+        expect( param.value ).to be( true )
+        param.value = '0'
+        expect( param.value ).to be( false )
+      end
+
+      it 'accepts checkboxes as booleans' do
+        param = Param.new( :name => :foo, :type => :check_box )
+        expect( param.value ).to be_nil
+        param.value = true
+        expect( param.value ).to be( true )
+        param.value = false
+        expect( param.value ).to be( false )
+      end
+
+      it 'accepts checkboxes as strings' do
+        param = Param.new( :name => :foo, :type => :check_box )
+        expect( param.value ).to be_nil
+        param.value = 'true'
+        expect( param.value ).to be( true )
+        param.value = 'false'
+        expect( param.value ).to be( false )
+      end
+
+      it 'parses date hashes' do
+        param = Param.new( :name => :foo, :type => :date )
+        param.value = { :year => '2013', :month => '9', :day => '16' }
+        expect( param.value ).to eql( Date.civil( 2013, 9, 16 ) )
+      end
+
+      it 'parses date strings' do
+        param = Param.new( :name => :foo, :type => :date )
+        param.value = '2013-09-16'
+        expect( param.value ).to eql( Date.civil( 2013, 9, 16 ) )
+      end
+
+      it 'passes everything else through untouched' do
+        param = Param.new( :name => :foo, :type => :text_field )
+        param.value = '2013-09-16'
+        expect( param.value ).to eql( '2013-09-16' )
+      end
+
+    end
+
+    describe '#hide' do
+
+      it 'sets the hidden option to true' do
+        expect( param.options[ :hidden ] ).to be_nil
+        param.hide
+        expect( param.options[ :hidden ] ).to be( true )
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/report_cat/core/report_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+include ReportCat::Core
+
+module ReportCat::Core
+
+  describe Report do
+
+    include SetupReports
+
+    before( :each ) do
+      @name = :test
+      @report = Report.new( :name => @name )
+    end
+
+    #############################################################################
+    # initialize
+
+    describe '#initialize' do
+
+      it 'initializes accessor values' do
+        expect( @report.name ).to eql( @name )
+        expect( @report.params ).to eql( [] )
+        expect( @report.columns ).to eql( [] )
+        expect( @report.rows ).to eql( [] )
+        expect( @report.charts ).to eql( [] )
+      end
+
+      it 'accepts arrays' do
+        array = [ 'a', 'b' ]
+
+        report = Report.new(
+            :from => array,
+            :joins => array,
+            :where => array,
+            :group_by => array,
+            :order_by => array
+        )
+
+        expect( report.from ).to eql( 'a,b' )
+        expect( report.joins ).to eql( 'a b' )
+        expect( report.where ).to eql( 'a and b' )
+        expect( report.group_by ).to eql( 'a,b' )
+        expect( report.order_by ).to eql( 'a,b' )
+      end
+
+    end
+
+    #############################################################################
+    # accept_array
+
+    describe '#accept_array' do
+
+      it 'joins arrays with the separator' do
+        expected = '1,2,3'
+        expect( @report.accept_array( [ '1', '2', '3' ], ',' ) ).to eql( expected )
+      end
+
+      it 'returns non arrays' do
+        expect( @report.accept_array( 1, ',' ) ).to eql( 1 )
+        expect( @report.accept_array( :foo, ',' ) ).to eql( :foo )
+      end
+
+    end
+
+    #############################################################################
+    # add_chart
+
+    describe '#add_chart' do
+
+      it 'adds a chart' do
+        name = :i_like_pie
+        type = :pie
+        label = :label
+        values = [ :value_1, :value_2 ]
+        options = { :sweet => true }
+
+        expect( @report.charts ).to be_empty
+        @report.add_chart( name, type, label, values, options )
+        expect( @report.charts.size ).to eql( 1 )
+
+        chart = @report.charts.first
+
+        expect( chart ).to be_an_instance_of( Chart )
+        expect( chart.name ).to eql( name )
+        expect( chart.type ).to eql( type )
+        expect( chart.label ).to eql( label )
+        expect( chart.values ).to eql( values )
+        expect( chart.options ).to eql( options )
+      end
+
+    end
+
+    #############################################################################
+    # add_column
+
+    describe '#add_column' do
+
+      it 'adds a column' do
+        name = :foo
+        type = :integer
+        options = { :sql => 'count( 1 )' }
+
+        expect( @report.columns ).to be_empty
+        @report.add_column( name, type, options )
+        expect( @report.columns.size ).to eql( 1 )
+
+        column = @report.columns.first
+        expect( column.name ).to eql( name )
+        expect( column.type ).to eql( type )
+        expect( column.options ).to eql( options )
+      end
+
+    end
+
+    #############################################################################
+    # add_param
+
+    describe '#add_param' do
+
+      it 'adds a param' do
+        name = :foo
+        type = :integer
+
+        expect( @report.params ).to be_empty
+        @report.add_param( name, type )
+        expect( @report.params.size ).to eql( 1 )
+
+        param = @report.params.first
+        expect( param ).to be_an_instance_of( Param )
+        expect( param.name ).to eql( name )
+        expect( param.type ).to eql( type )
+      end
+
+    end
+
+    #############################################################################
+    # column
+
+    describe '#column' do
+
+      before( :each ) do
+        setup_reports
+      end
+
+      it 'returns the named column' do
+        expect( @report.columns.size ).to be > 1
+        @report.columns.each_index do |i|
+          column = @report.columns[ i ]
+          expect( @report.column( column.name ) ).to eql( column )
+        end
+
+      end
+
+
+      it 'returns nil if it is unable to find the column' do
+        expect( @report.column( :does_not_exist ) ).to be_nil
+      end
+
+    end
+
+
+    #############################################################################
+    # column_index
+
+    describe '#column_index' do
+
+      before( :each ) do
+        setup_reports
+      end
+
+      it 'returns the index of the named column' do
+        expect( @report.columns.size ).to be > 1
+        @report.columns.each_index do |i|
+          column = @report.columns[ i ]
+          expect( @report.column_index( column.name ) ).to eql( i )
+        end
+
+      end
+
+
+      it 'returns nil if it is unable to find the column' do
+        expect( @report.column_index( :does_not_exist ) ).to be_nil
+      end
+
+    end
+
+
+    #############################################################################
+    # generate
+
+    describe '#generate' do
+
+      before( :each ) do
+        setup_reports
+        allow( @report ).to receive( :query ).and_return( nil )
+      end
+
+      it 'applies passed in options to params of the same name' do
+        expect( @report.param( :text_field_test ).value ).to be_nil
+        @report.generate( :text_field_test => 'foobar' )
+        expect( @report.param( :text_field_test ).value ).to eql( 'foobar' )
+      end
+
+    end
+
+    #############################################################################
+    # param
+
+    describe '#param' do
+
+      before( :each ) do
+        @param = @report.add_param( :foo, :integer )
+      end
+
+      it 'finds a parameter by name' do
+        expect( @report.param( :foo ) ).to be( @param )
+      end
+
+      it 'returns nil if it can not find it' do
+        expect( @report.param( :bar ) ).to be_nil
+      end
+
+    end
+
+    #############################################################################
+    # to_csv
+
+    describe '#to_csv' do
+
+      before( :each ) do
+        setup_reports
+        allow( @report ).to receive( :query ).and_return( nil )
+      end
+
+      it 'generates CSV' do
+        expect( @report.to_csv ).to eql_file( 'spec/data/lib/report.csv' )
+      end
+
+    end
+
+    #############################################################################
+    # attributes
+
+    describe '#attributes' do
+
+      before( :each ) do
+        setup_reports
+      end
+
+      it 'includes the name as both name and id' do
+        expect( @report.attributes[ :id ] ).to eql( @report.name )
+        expect( @report.attributes[ :name ] ).to eql( @report.name )
+      end
+
+      it 'includes back if defined' do
+        back = @report.attributes
+        expect( @report.attributes.has_key?( :back ) ).to be( false )
+        @report.back = back
+        expect( @report.attributes[ :back ] ).to eql( back )
+      end
+
+      it 'returns a hash of param names to values' do
+        @report.params.each do |param|
+          expect( @report.attributes[ param.name ] ).to eql( param.value )
+        end
+      end
+
+    end
+
+    #############################################################################
+    # query
+
+    describe '#query' do
+
+      before( :each ) do
+        setup_reports
+       end
+
+      it 'initializes rows' do
+        @report.rows << []
+        expect( @report.rows.size ).to be > 0
+
+        expect( @report ).to receive( :to_sql ).and_return( nil )
+        allow( ActiveRecord::Base.connection ).to receive( :execute ).and_return( nil )
+
+        @report.send( :query )
+        expect( @report.rows.size ).to eql( 0 )
+      end
+
+      it 'executes SQL against ActiveRecord' do
+        sql = 'foobar
+'
+        expect( @report ).to receive( :to_sql ).and_return( sql )
+        expect( ActiveRecord::Base.connection ).to receive( :execute ).with( sql ).and_return( nil )
+        @report.send( :query )
+      end
+
+      it 'tolerates nil results from ActiveRecord' do
+        expect( @report ).to receive( :to_sql ).and_return( nil )
+        expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( nil )
+        @report.send( :query )
+      end
+
+      it 'populates rows with the results of the query' do
+        results = [ [1], [2] ]
+
+        expect( @report ).to receive( :to_sql ).and_return( nil )
+        expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( results )
+        @report.send( :query )
+        expect( @report.rows.size ).to eql( results.size )
+        results.each_index { |i| expect( @report.rows[ i ] ).to eql( results[ i ] ) }
+      end
+
+      it 'post processes each column' do
+        expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( [] )
+
+        @report.columns.each { |c| expect( c ).to receive( :post_process ).with( @report ) }
+        @report.send( :query )
+      end
+
+    end
+
+    #############################################################################
+    # to_sql
+
+    describe '#to_sql' do
+
+      before( :each ) do
+        setup_reports
+        allow( @report ).to receive( :query ).and_return( nil )
+      end
+
+      it 'generates SQL' do
+        expect( @report.send( :to_sql ) ).to eql_file( 'spec/data/lib/report.sql' )
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/report_cat/engine_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe ReportCat::Engine do
+
+  it 'isolates the ReportCat namespace' do
+    expect( ReportCat::Engine.isolated ).to be( true )
+  end
+
+end

data/spec/lib/report_cat/matchers/have_chart_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+include ReportCat::Core
+
+describe RSpec::Matchers, 'have_chart' do
+
+  let( :name ) { :test }
+  let( :type ) { :integer }
+  let( :label ) { :label }
+  let( :values ) { [] }
+  let( :options ) { { :foo => true } }
+
+  before( :each ) do
+    @report = Report.new
+    @chart = @report.add_chart( name, type, label, values, options )
+  end
+
+  it 'passes if the report has the chart' do
+    expect( @report ).to have_chart( name )
+    expect( @report ).to have_chart( name ).with_type( type )
+    expect( @report ).to have_chart( name ).with_label( label )
+    expect( @report ).to have_chart( name ).with_values( values )
+    expect( @report ).to have_chart( name ).with_options( options )
+    expect( @report ).to have_chart( name ).with_type( type ).with_label( label ).with_values( values ).with_options( options )
+  end
+
+  it 'fails if the report does not have the chart' do
+    expect( @report ).to_not have_chart( :foo )
+    expect( @report ).to_not have_chart( name ).with_type( :foo )
+    expect( @report ).to_not have_chart( name ).with_label( :foo )
+    expect( @report ).to_not have_chart( name ).with_values( :foo )
+    expect( @report ).to_not have_chart( name ).with_options( :foo )
+    expect( @report ).to_not have_chart( name ).with_type( :foo ).with_label( :foo ).with_values( :foo ).with_options( :foo )
+  end
+
+end

data/spec/lib/report_cat/matchers/have_column_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+include ReportCat::Core
+
+describe RSpec::Matchers, 'have_column' do
+
+  let( :name ) { :test }
+  let( :type ) { :integer }
+  let( :options ) { { :foo => true } }
+
+  before( :each ) do
+    @report = Report.new
+    @column = @report.add_column( name, type, options  )
+  end
+
+  it 'passes if the report has the column' do
+    expect( @report ).to have_column( name )
+    expect( @report ).to have_column( name ).with_type( type )
+    expect( @report ).to have_column( name ).with_options( options )
+    expect( @report ).to have_column( name ).with_type( type ).with_options( options )
+  end
+
+  it 'fails if the report does not have the column' do
+    expect( @report ).to_not have_column( :foo )
+    expect( @report ).to_not have_column( name ).with_type( :foo )
+    expect( @report ).to_not have_column( name ).with_options( :foo )
+    expect( @report ).to_not have_column( name ).with_type( :foo ).with_options( :foo )
+  end
+
+end

data/spec/lib/report_cat/matchers/have_param_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+include ReportCat::Core
+
+describe RSpec::Matchers, 'have_param' do
+
+  let( :name ) { :test }
+  let( :type ) { :select }
+  let( :value ) { :value }
+  let( :options ) { [ :foo, :bar ] }
+
+  before( :each ) do
+    @report = Report.new
+    @param = @report.add_param( name, type, value, options )
+  end
+
+  it 'passes if the report has the param' do
+    expect( @report ).to have_param( name )
+    expect( @report ).to have_param( name ).with_type( type )
+    expect( @report ).to have_param( name ).with_value( value )
+    expect( @report ).to have_param( name ).with_options( options )
+    expect( @report ).to have_param( name ).with_type( type ).with_value( value ).with_options( options )
+  end
+
+  it 'fails if the report does not have the param' do
+    expect( @report ).to_not have_param( :foo )
+    expect( @report ).to_not have_param( name ).with_type( :foo )
+    expect( @report ).to_not have_param( name ).with_value( :foo )
+    expect( @report ).to_not have_param( name ).with_options( :foo )
+    expect( @report ).to_not have_param( name ).with_type( :foo ).with_value( :foo ).with_options( :foo )
+  end
+
+end