datagrid 1.6.1 → 1.6.2

data/spec/datagrid/filters/date_time_filter_spec.rb

@@ -1,157 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::DateTimeFilter do
-  {:active_record => Entry, :mongoid => MongoidEntry}.each do |orm, klass|
-    describe "with orm #{orm}", orm => true do
-      describe "timestamp to timestamp conversion" do
-        let(:klass) { klass }
-
-        let(:grid) do
-          test_report(:created_at => _created_at) do
-            scope { klass }
-            filter(:created_at, :datetime, :range => true)
-          end
-        end
-
-        subject do
-          grid.assets.to_a
-        end
-
-        def entry_dated(date)
-          klass.create(:created_at => date)
-        end
-
-        context "when single datetime paramter given" do
-          let(:_created_at) { Time.now.change(sec: 0) }
-          it { should include(entry_dated(_created_at)) }
-          it { should_not include(entry_dated(_created_at - 1.second))}
-          it { should_not include(entry_dated(_created_at + 1.second))}
-        end
-
-        context "when range datetime range given" do
-          let(:_created_at) { [Time.now.beginning_of_day, Time.now.end_of_day] }
-          it { should include(entry_dated(1.second.ago))}
-          it { should include(entry_dated(Date.today.to_time))}
-          it { should include(entry_dated(Time.now.end_of_day.to_time))}
-          it { should_not include(entry_dated(Date.yesterday.end_of_day))}
-          it { should_not include(entry_dated(Date.tomorrow.beginning_of_day))}
-        end
-      end
-
-    end
-  end
-
-  it "should support datetime range given as array argument" do
-    e1 = Entry.create!(:created_at => Time.new(2013, 1, 1, 1, 0))
-    e2 = Entry.create!(:created_at => Time.new(2013, 1, 1, 2, 0))
-    e3 = Entry.create!(:created_at => Time.new(2013, 1, 1, 3, 0))
-    report = test_report(:created_at => [Time.new(2013, 1, 1, 1, 30).to_s, Time.new(2013, 1, 1, 2, 30).to_s]) do
-      scope { Entry }
-      filter(:created_at, :datetime, :range => true)
-    end
-    expect(report.assets).not_to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).not_to include(e3)
-  end
-
-  it "should support minimum datetime argument" do
-    e1 = Entry.create!(:created_at => Time.new(2013, 1, 1, 1, 0))
-    e2 = Entry.create!(:created_at => Time.new(2013, 1, 1, 2, 0))
-    e3 = Entry.create!(:created_at => Time.new(2013, 1, 1, 3, 0))
-    report = test_report(:created_at => [Time.new(2013, 1, 1, 1, 30).to_s, nil]) do
-      scope { Entry }
-      filter(:created_at, :datetime, :range => true)
-    end
-    expect(report.assets).not_to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).to include(e3)
-  end
-
-  it "should support maximum datetime argument" do
-    e1 = Entry.create!(:created_at => Time.new(2013, 1, 1, 1, 0))
-    e2 = Entry.create!(:created_at => Time.new(2013, 1, 1, 2, 0))
-    e3 = Entry.create!(:created_at => Time.new(2013, 1, 1, 3, 0))
-    report = test_report(:created_at => [nil, Time.new(2013, 1, 1, 2, 30).to_s]) do
-      scope { Entry }
-      filter(:created_at, :datetime, :range => true)
-    end
-    expect(report.assets).to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).not_to include(e3)
-  end
-
-  it "should find something in one second interval" do
-
-    e1 = Entry.create!(:created_at => Time.new(2013, 1, 1, 1, 0))
-    e2 = Entry.create!(:created_at => Time.new(2013, 1, 1, 2, 0))
-    e3 = Entry.create!(:created_at => Time.new(2013, 1, 1, 3, 0))
-    report = test_report(:created_at => Time.new(2013, 1, 1, 2, 0)..Time.new(2013, 1, 1, 2, 0)) do
-      scope { Entry }
-      filter(:created_at, :datetime, :range => true)
-    end
-    expect(report.assets).not_to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).not_to include(e3)
-  end
-  it "should reverse invalid range" do
-
-    range = Time.new(2013, 1, 1, 3, 0)..Time.new(2013, 1, 1, 1, 0)
-    e1 = Entry.create!(:created_at => Time.new(2013, 1, 1, 1, 0))
-    e2 = Entry.create!(:created_at => Time.new(2013, 1, 1, 2, 0))
-    e3 = Entry.create!(:created_at => Time.new(2013, 1, 1, 3, 0))
-    report = test_report(:created_at => range) do
-      scope { Entry }
-      filter(:created_at, :datetime, :range => true)
-    end
-    expect(report.created_at).to eq([range.last, range.first])
-    expect(report.assets).to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).to include(e3)
-  end
-
-
-  it "should support block" do
-    report = test_report(:created_at => Time.now) do
-      scope { Entry }
-      filter(:created_at, :datetime, :range => true) do |value|
-        where("created_at >= ?", value)
-      end
-    end
-    expect(report.assets).not_to include(Entry.create!(:created_at => 1.day.ago))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.now+1.day))
-  end
-
-
-  context "when datetime format is configured" do
-    around(:each) do |example|
-      with_datetime_format("%m/%d/%Y %H:%M") do
-        example.run
-      end
-    end
-
-    it "should have configurable datetime format" do
-      report = test_report(:created_at => "10/01/2013 01:00") do
-        scope  {Entry}
-        filter(:created_at, :datetime)
-      end
-      expect(report.created_at).to eq(Time.new(2013,10,01,1,0))
-    end
-
-    it "should support default explicit datetime" do
-      report = test_report(:created_at => Time.parse("2013-10-01 01:00")) do
-        scope  {Entry}
-        filter(:created_at, :datetime)
-      end
-      expect(report.created_at).to eq(Time.new(2013,10,01,1,0))
-    end
-  end
-
-
-  it "should automatically reverse Array if first more than last" do
-    report = test_report(:created_at => ["2013-01-01 01:00", "2012-01-01 01:00"]) do
-      scope  {Entry}
-      filter(:created_at, :datetime, :range => true)
-    end
-    expect(report.created_at).to eq([Time.new(2012, 01, 01, 1, 0), Time.new(2013, 01, 01, 1, 0)])
-  end
-end

data/spec/datagrid/filters/dynamic_filter_spec.rb

@@ -1,175 +0,0 @@
-require "spec_helper"
-
-
-describe Datagrid::Filters::DynamicFilter do
-  let(:report) do
-    test_report do
-      scope  {Entry}
-      filter(:condition, :dynamic)
-    end
-  end
-
-  it "should support = operation" do
-    report.condition = [:name, "=", "hello"]
-    expect(report.assets).to include(Entry.create!(:name => 'hello'))
-    expect(report.assets).not_to include(Entry.create!(:name => 'bye'))
-  end
-
-  it "should support >= operation" do
-    report.condition = [:name, ">=", "d"]
-    expect(report.assets).to include(Entry.create!(:name => 'x'))
-    expect(report.assets).to include(Entry.create!(:name => 'd'))
-    expect(report.assets).not_to include(Entry.create!(:name => 'a'))
-  end
-
-  it "should blank value" do
-    report.condition = [:name, "=", ""]
-    expect(report.assets).to include(Entry.create!(:name => 'hello'))
-  end
-
-  it "should support =~ operation on strings" do
-    report.condition = [:name, "=~", "ell"]
-    expect(report.assets).to include(Entry.create!(:name => 'hello'))
-    expect(report.assets).not_to include(Entry.create!(:name => 'bye'))
-  end
-
-  it "should support =~ operation integers" do
-    report.condition = [:group_id, "=~", 2]
-    expect(report.assets).to include(Entry.create!(:group_id => 2))
-    expect(report.assets).not_to include(Entry.create!(:group_id => 1))
-    expect(report.assets).not_to include(Entry.create!(:group_id => 3))
-  end
-
-  it "should support >= operation on integer" do
-    report.condition = [:group_id, ">=", 2]
-    expect(report.assets).to include(Entry.create!(:group_id => 3))
-    expect(report.assets).not_to include(Entry.create!(:group_id => 1))
-  end
-
-  it "should support <= operation on integer" do
-    report.condition = [:group_id, "<=", 2]
-    expect(report.assets).to include(Entry.create!(:group_id => 1))
-    expect(report.assets).not_to include(Entry.create!(:group_id => 3))
-  end
-
-  it "should support <= operation on integer with string value" do
-    report.condition = [:group_id, "<=", '2']
-    expect(report.assets).to include(Entry.create!(:group_id => 1))
-    expect(report.assets).to include(Entry.create!(:group_id => 2))
-    expect(report.assets).not_to include(Entry.create!(:group_id => 3))
-  end
-
-  it "should nullify incorrect value for integer" do
-    report.condition = [:group_id, "<=", 'aa']
-    expect(report.condition).to eq([:group_id, "<=", nil])
-  end
-
-  it "should nullify incorrect value for date" do
-    report.condition = [:shipping_date, "<=", 'aa']
-    expect(report.condition).to eq([:shipping_date, "<=", nil])
-  end
-
-  it "should nullify incorrect value for datetime" do
-    report.condition = [:created_at, "<=", 'aa']
-    expect(report.condition).to eq([:created_at, "<=", nil])
-  end
-
-  it "should support date comparation operation by timestamp column" do
-    report.condition = [:created_at, "<=", '1986-08-05']
-    expect(report.condition).to eq([:created_at, "<=", Date.parse('1986-08-05')])
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-04 01:01:01')))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-05 23:59:59')))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-05 00:00:00')))
-    expect(report.assets).not_to include(Entry.create!(:created_at => Time.parse('1986-08-06 00:00:00')))
-    expect(report.assets).not_to include(Entry.create!(:created_at => Time.parse('1986-08-06 23:59:59')))
-  end
-
-  it "should support date = operation by timestamp column" do
-    report.condition = [:created_at, "=", '1986-08-05']
-    expect(report.condition).to eq([:created_at, "=", Date.parse('1986-08-05')])
-    expect(report.assets).not_to include(Entry.create!(:created_at => Time.parse('1986-08-04 23:59:59')))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-05 23:59:59')))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-05 00:00:01')))
-    #TODO: investigate SQLite issue and uncomment this line
-    #report.assets.should include(Entry.create!(:created_at => Time.parse('1986-08-05 00:00:00')))
-    expect(report.assets).not_to include(Entry.create!(:created_at => Time.parse('1986-08-06 23:59:59')))
-  end
-
-  it "should support date =~ operation by timestamp column" do
-    report.condition = [:created_at, "=~", '1986-08-05']
-    expect(report.condition).to eq([:created_at, "=~", Date.parse('1986-08-05')])
-    expect(report.assets).not_to include(Entry.create!(:created_at => Time.parse('1986-08-04 23:59:59')))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-05 23:59:59')))
-    expect(report.assets).to include(Entry.create!(:created_at => Time.parse('1986-08-05 00:00:01')))
-    #TODO: investigate SQLite issue and uncomment this line
-    #report.assets.should include(Entry.create!(:created_at => Time.parse('1986-08-05 00:00:00')))
-    expect(report.assets).not_to include(Entry.create!(:created_at => Time.parse('1986-08-06 23:59:59')))
-  end
-
-  it "should support operations for invalid date" do
-    report.condition = [:shipping_date, "<=", '1986-08-05']
-    expect(report.assets).to include(Entry.create!(:shipping_date => '1986-08-04'))
-    expect(report.assets).to include(Entry.create!(:shipping_date => '1986-08-05'))
-    expect(report.assets).not_to include(Entry.create!(:shipping_date => '1986-08-06'))
-  end
-  it "should support operations for invalid date" do
-    report.condition = [:shipping_date, "<=", Date.parse('1986-08-05')]
-    expect(report.assets).to include(Entry.create!(:shipping_date => '1986-08-04'))
-    expect(report.assets).to include(Entry.create!(:shipping_date => '1986-08-05'))
-    expect(report.assets).not_to include(Entry.create!(:shipping_date => '1986-08-06'))
-  end
-
-  it "should support allow_nil and allow_blank options" do
-    grid = test_report do
-      scope {Entry}
-      filter(:condition, :dynamic, :allow_nil => true, :allow_blank => true, operations: ['>=', '<=']) do |(field, operation, value), scope|
-        if value.blank?
-          scope.where(disabled: false)
-        else
-          scope.where("#{field} #{operation} ?", value)
-        end
-      end
-    end
-
-    expect(grid.assets).to_not include(Entry.create!(disabled: true))
-    expect(grid.assets).to include(Entry.create!(disabled: false))
-
-    grid.condition = [:group_id, '>=', 3]
-    expect(grid.assets).to include(Entry.create!(disabled: true, group_id: 4))
-    expect(grid.assets).to_not include(Entry.create!(disabled: false, group_id: 2))
-  end
-
-  it "should support custom operations" do
-    entry = Entry.create!(name: 'hello')
-
-    grid = test_report do
-      scope {Entry}
-      filter(
-        :condition, :dynamic, operations: ["=", "!="]
-      ) do |(field, operation, value), scope|
-        if operation == "!="
-          scope.where("#{field} != ?", value)
-        else
-          default_filter
-        end
-      end
-    end
-
-    grid.condition = ["name", "=", "hello"]
-    expect(grid.assets).to include(entry)
-    grid.condition = ["name", "!=", "hello"]
-    expect(grid.assets).to_not include(entry)
-    grid.condition = ["name", "=", "hello1"]
-    expect(grid.assets).to_not include(entry)
-    grid.condition = ["name", "!=", "hello1"]
-    expect(grid.assets).to include(entry)
-  end
-
-  it "should raise if unknown operation" do
-    report.condition = [:shipping_date, "<>", '1996-08-05']
-    expect{
-      report.assets
-    }.to raise_error(Datagrid::FilteringError)
-  end
-
-end

data/spec/datagrid/filters/enum_filter_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::EnumFilter do
-
-  it "should support select option" do
-    report = test_report do
-      scope {Entry}
-      filter(:group_id, :enum, :select =>  [1,2] )
-    end
-    expect(report.filter_by_name(:group_id).select(report)).to eq([1,2])
-  end
-
-  it "should support select option as proc" do
-    grid = test_report do
-      scope {Entry}
-      filter(:group_id, :enum, :select => proc { [1,2] })
-    end
-    expect(grid.filter_by_name(:group_id).select(grid)).to eq([1,2])
-  end
-
-  it "should support select option as proc with instace input" do
-    klass = test_report do
-              scope {Entry}
-              filter(:group_id, :enum, :select => proc { |obj| obj.object_id })
-            end.class
-    instance = klass.new
-    expect(klass.filter_by_name(:group_id).select(instance)).to eq(instance.object_id)
-  end
-
-  it "should initialize select option only on instanciation" do
-    class ReportWithLazySelect
-      include Datagrid
-      scope {Entry}
-      filter(:group_id, :enum, :select => proc { raise 'hello' })
-    end
-  end
-
-
-  it "should support select given as symbol" do
-    report = test_report do
-      scope {Entry}
-      filter(:group_id, :enum, :select => :selectable_group_ids)
-      def selectable_group_ids
-        [1,3,5]
-      end
-    end
-
-    expect(report.filter_by_name(:group_id).select(report)).to eq([1,3,5])
-  end
-
-end

data/spec/datagrid/filters/extended_boolean_filter_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::ExtendedBooleanFilter do
-
-  it "should support select option" do
-    grid = test_report do
-      scope {Entry}
-      filter(:disabled, :xboolean)
-    end
-    expect(grid.filter_by_name(:disabled).select(grid)).to eq([["Yes", "YES"], ["No", "NO"]])
-  end
-
-  it "should generate pass boolean value to filter block" do
-    grid = test_report do
-      scope {Entry}
-      filter(:disabled, :xboolean)
-    end
-
-    disabled_entry = Entry.create!(:disabled => true)
-    enabled_entry = Entry.create!(:disabled => false)
-
-    expect(grid.disabled).to be_nil
-    expect(grid.assets).to include(disabled_entry, enabled_entry)
-    grid.disabled = "YES"
-
-    expect(grid.disabled).to eq("YES")
-    expect(grid.assets).to include(disabled_entry)
-    expect(grid.assets).not_to include(enabled_entry)
-    grid.disabled = "NO"
-    expect(grid.disabled).to eq("NO")
-    expect(grid.assets).to include(enabled_entry)
-    expect(grid.assets).not_to include(disabled_entry)
-  end
-
-  it "should normalize true/false as YES/NO" do
-    grid = test_report do
-      scope {Entry}
-      filter(:disabled, :xboolean)
-    end
-    grid.disabled = true
-    expect(grid.disabled).to eq("YES")
-    grid.disabled = false
-    expect(grid.disabled).to eq("NO")
-  end
-
-end

data/spec/datagrid/filters/float_filter_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::FloatFilter do
-  
-  it "should support float values" do
-    g1 = Group.create!(:rating => 1.5)
-    g2 = Group.create!(:rating => 1.6)
-    report = test_report(:rating => 1.5) do
-      scope { Group }
-      filter(:rating, :float)
-    end
-    expect(report.assets).to include(g1)
-    expect(report.assets).not_to include(g2)
-  end
-end