datagrid 1.6.1 → 1.6.2

data/spec/datagrid/drivers/mongoid_spec.rb

@@ -1,109 +0,0 @@
-require "spec_helper"
-
-describe Datagrid::Drivers::Mongoid, :mongoid do
-
-  describe ".match?" do
-    
-    subject { described_class }
-
-    it {should be_match(MongoidEntry)}
-    it {should be_match(MongoidEntry.scoped)}
-    it {should_not be_match(Entry.where(:id => 1))}
-
-  end
-  describe "api" do
-
-    subject do
-      MongoidGrid.new(
-        defined?(_attributes) ? _attributes : {}
-      )
-    end
-
-    let!(:first) do
-      MongoidEntry.create!(
-        :group_id => 2,
-        :name => "Main First",
-        :disabled => false
-      )
-    end
-    let!(:second) do
-      MongoidEntry.create!(
-        :group_id => 3,
-        :name => "Main Second",
-        :disabled => true
-      )
-    end
-
-
-    describe '#assets' do
-      subject { super().assets }
-      it {should include(first, second)}
-    end
-
-    describe '#assets' do
-      subject { super().assets }
-      describe '#size' do
-        subject { super().size }
-        it {should == 2}
-      end
-    end
-
-    describe '#rows' do
-      subject { super().rows }
-      it {should == [["Main First", 2, false], ["Main Second", 3, true]]}
-    end
-
-    describe '#header' do
-      subject { super().header }
-      it {should ==[ "Name", "Group", "Disabled"]}
-    end
-
-    describe '#data' do
-      subject { super().data }
-      it {should == [[ "Name", "Group", "Disabled"], ["Main First", 2, false], ["Main Second", 3, true]]}
-    end
-
-
-    describe "when some filters specified" do
-      let(:_attributes) { {:from_group_id => 3} }
-
-      describe '#assets' do
-        subject { super().assets.map(&:_id) }
-        it {should_not include(first.id)}
-      end
-
-      describe '#assets' do
-        subject { super().assets }
-        it {should include(second)}
-      end
-    end
-
-    describe "when reverse ordering is specified" do
-      let(:_attributes) { {:order => :name, :descending => true} }
-
-      describe '#rows' do
-        subject { super().rows }
-        it {should == [["Main Second", 3, true], ["Main First", 2, false]]}
-      end
-    end
-
-    it "should not provide default order for non declared fields" do
-      expect {
-        test_report(:order => :test) do
-          scope { MongoidEntry }
-          column(:test)
-        end.assets
-      }.to raise_error(Datagrid::OrderUnsupported)
-    end
-
-    it "should support batch_size" do
-      report = test_report do
-        scope { MongoidEntry }
-        self.batch_size = 1 
-        column(:name)
-      end
-
-      expect(report.data).to eq([["Name"], ["Main First"], ["Main Second"]])
-    end
-  end
-end

data/spec/datagrid/drivers/sequel_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Drivers::Sequel do
-
-  describe ".match?" do
-    
-    subject { described_class }
-
-    it {should be_match(SequelEntry)}
-    it {should be_match(SequelEntry.where(:id => 1))}
-    it {should_not be_match(Entry.where(:id => 1))}
-
-  end
-  describe "api" do
-
-    subject do
-      SequelGrid.new(
-        defined?(_attributes) ? _attributes : {}
-      )
-    end
-
-    let!(:first) do
-      SequelEntry.create(
-        :group_id => 2,
-        :name => "Main First",
-        :disabled => false
-      )
-    end
-    let!(:second) do
-      SequelEntry.create(
-        :group_id => 3,
-        :name => "Main Second",
-        :disabled => true
-      )
-    end
-
-
-    describe '#assets' do
-      subject { super().assets }
-      it {should include(first, second)}
-    end
-
-    describe '#assets' do
-      subject { super().assets }
-      describe '#size' do
-        subject { super().count }
-        it {should == 2}
-      end
-    end
-
-    describe '#rows' do
-      subject { super().rows }
-      it {should == [["Main First", 2, false], ["Main Second", 3, true]]}
-    end
-
-    describe '#header' do
-      subject { super().header }
-      it {should ==[ "Name", "Group", "Disabled"]}
-    end
-
-    describe '#data' do
-      subject { super().data }
-      it {should == [[ "Name", "Group", "Disabled"], ["Main First", 2, false], ["Main Second", 3, true]]}
-    end
-
-
-    describe "when some filters specified" do
-      let(:_attributes) { {:from_group_id => 3} }
-
-      describe '#assets' do
-        subject { super().assets.map(&:id) }
-        it {should_not include(first.id)}
-      end
-
-      describe '#assets' do
-        subject { super().assets }
-        it {should include(second)}
-      end
-    end
-
-    describe "when reverse ordering is specified" do
-      let(:_attributes) { {:order => :name, :descending => true} }
-
-      describe '#rows' do
-        subject { super().rows }
-        it {should == [["Main Second", 3, true], ["Main First", 2, false]]}
-      end
-    end
-
-    it "should provide default order for non declared fields" do
-      expect {
-        test_report(:order => :test) do
-          scope { SequelEntry }
-          column(:test) do
-            'test'
-          end
-        end.assets
-      }.to raise_error(Datagrid::OrderUnsupported)
-    end
-
-    it "should support batch_size" do
-      report = test_report do
-        scope { SequelEntry }
-        self.batch_size = 1 
-        column(:name)
-      end
-
-      expect(report.data).to eq([["Name"], ["Main First"], ["Main Second"]])
-    end
-  end
-end

data/spec/datagrid/filters/base_filter_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::BaseFilter do
-  
-
-  it "should support default option as block" do
-    report = test_report do
-      scope {Entry}
-      filter(:name, :string, :default => :name_default)
-      def name_default
-        'hello'
-      end
-    end
-    expect(report.assets).to include(Entry.create!(:name => "hello"))
-    expect(report.assets).not_to include(Entry.create!(:name => "world"))
-    expect(report.assets).not_to include(Entry.create!(:name => ""))
-  end
-
-end

data/spec/datagrid/filters/boolean_enum_filter_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::BooleanEnumFilter do
-   
-end

data/spec/datagrid/filters/composite_filters_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Filters::CompositeFilters do
-  
-  describe ".date_range_filters" do
-    
-    it "should generate from date and to date filters" do
-      e1 = Entry.create!(:shipping_date => 6.days.ago)
-      e2 = Entry.create!(:shipping_date => 4.days.ago)
-      e3 = Entry.create!(:shipping_date => 1.days.ago)
-      assets = test_report(:from_shipping_date => 5.days.ago, :to_shipping_date => 2.day.ago) do
-        scope {Entry}
-        date_range_filters(:shipping_date)
-      end.assets
-
-      expect(assets).to include(e2)
-      expect(assets).not_to include(e1, e3)
-    end
-
-    it "should support options" do
-      report = test_report do
-        report = date_range_filters(:shipping_date, {:default => 10.days.ago.to_date}, {:default => Date.today})
-      end
-      expect(report.from_shipping_date).to eq(10.days.ago.to_date)
-      expect(report.to_shipping_date).to eq(Date.today)
-    end
-    it "should support table name in field" do
-      report = test_report do
-        report = date_range_filters("entries.shipping_date", {:default => 10.days.ago.to_date}, {:default => Date.today})
-      end
-      expect(report.from_entries_shipping_date).to eq(10.days.ago.to_date)
-      expect(report.to_entries_shipping_date).to eq(Date.today)
-    end
-  end
-  
-  describe ".integer_range_filters" do
-    
-    it "should generate from integer and to integer filters" do
-      e1 = Entry.create!(:group_id => 1)
-      e2 = Entry.create!(:group_id => 3)
-      e3 = Entry.create!(:group_id => 5)
-      assets = test_report(:from_group_id => 2, :to_group_id => 4) do
-        scope {Entry}
-        integer_range_filters(:group_id)
-      end.assets
-
-      expect(assets).to include(e2)
-      expect(assets).not_to include(e1, e3)
-    end
-    it "should support options" do
-      report = test_report do
-        report = integer_range_filters(:group_id, {:default => 0}, {:default => 100})
-      end
-      expect(report.from_group_id).to eq(0)
-      expect(report.to_group_id).to eq(100)
-    end
-    it "should table name in field name" do
-      report = test_report do
-        report = integer_range_filters("entries.group_id", {:default => 0}, {:default => 100})
-      end
-      expect(report.from_entries_group_id).to eq(0)
-      expect(report.to_entries_group_id).to eq(100)
-    end
-  end
-end

data/spec/datagrid/filters/date_filter_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-require "active_support/testing/time_helpers"
-
-describe Datagrid::Filters::DateFilter do
-
-  it "should support date range argument" do
-    e1 = Entry.create!(:created_at => 7.days.ago)
-    e2 = Entry.create!(:created_at => 4.days.ago)
-    e3 = Entry.create!(:created_at => 1.day.ago)
-    report = test_report(:created_at => 5.day.ago..3.days.ago) do
-      scope { Entry }
-      filter(:created_at, :date)
-    end
-    expect(report.assets).not_to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).not_to include(e3)
-  end
-
-  {:active_record => Entry, :mongoid => MongoidEntry, :sequel => SequelEntry}.each do |orm, klass|
-    describe "with orm #{orm}", orm => true do
-      describe "date to timestamp conversion" do
-        let(:klass) { klass }
-        subject do
-          test_report(:created_at => _created_at) do
-            scope { klass }
-            filter(:created_at, :date, :range => true)
-          end.assets.to_a
-        end
-
-        def entry_dated(date)
-          klass.create(:created_at => date)
-        end
-
-        context "when single date paramter given" do
-          let(:_created_at) { Date.today }
-          it { should include(entry_dated(1.second.ago))}
-          it { should include(entry_dated(Date.today.end_of_day))}
-          it { should_not include(entry_dated(Date.today.beginning_of_day - 1.second))}
-          it { should_not include(entry_dated(Date.today.end_of_day + 1.second))}
-        end
-
-        context "when range date range given" do
-          let(:_created_at) { [Date.yesterday, Date.today] }
-          it { should include(entry_dated(1.second.ago))}
-          it { should include(entry_dated(1.day.ago))}
-          it { should include(entry_dated(Date.today.end_of_day))}
-          it { should include(entry_dated(Date.yesterday.beginning_of_day))}
-          it { should_not include(entry_dated(Date.yesterday.beginning_of_day - 1.second))}
-          it { should_not include(entry_dated(Date.today.end_of_day + 1.second))}
-        end
-      end
-
-    end
-  end
-
-  it "should support date range given as array argument" do
-    e1 = Entry.create!(:created_at => 7.days.ago)
-    e2 = Entry.create!(:created_at => 4.days.ago)
-    e3 = Entry.create!(:created_at => 1.day.ago)
-    report = test_report(:created_at => [5.day.ago.to_date.to_s, 3.days.ago.to_date.to_s]) do
-      scope { Entry }
-      filter(:created_at, :date, :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 date argument" do
-    e1 = Entry.create!(:created_at => 7.days.ago)
-    e2 = Entry.create!(:created_at => 4.days.ago)
-    e3 = Entry.create!(:created_at => 1.day.ago)
-    report = test_report(:created_at => [5.day.ago.to_date.to_s, nil]) do
-      scope { Entry }
-      filter(:created_at, :date, :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 date argument" do
-    e1 = Entry.create!(:created_at => 7.days.ago)
-    e2 = Entry.create!(:created_at => 4.days.ago)
-    e3 = Entry.create!(:created_at => 1.day.ago)
-    report = test_report(:created_at => [nil, 3.days.ago.to_date.to_s]) do
-      scope { Entry }
-      filter(:created_at, :date, :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 day interval" do
-
-    e1 = Entry.create!(:created_at => 7.days.ago)
-    e2 = Entry.create!(:created_at => 4.days.ago)
-    e3 = Entry.create!(:created_at => 1.day.ago)
-    report = test_report(:created_at => (4.days.ago.to_date..4.days.ago.to_date)) do
-      scope { Entry }
-      filter(:created_at, :date, :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 invert invalid range" do
-    range = 1.days.ago..7.days.ago
-    e1 = Entry.create!(:created_at => 7.days.ago)
-    e2 = Entry.create!(:created_at => 4.days.ago)
-    e3 = Entry.create!(:created_at => 1.day.ago)
-    report = test_report(:created_at => range) do
-      scope { Entry }
-      filter(:created_at, :date, :range => true)
-    end
-    expect(report.created_at).to eq([range.last.to_date, range.first.to_date])
-    expect(report.assets).to include(e1)
-    expect(report.assets).to include(e2)
-    expect(report.assets).to include(e3)
-  end
-
-
-  it "should support block" do
-    date = Date.new(2018, 01, 07)
-    time = Time.utc(2018, 01, 07, 2, 2)
-    report = test_report(:created_at => date) do
-      scope { Entry }
-      filter(:created_at, :date, :range => true) do |value|
-        where("created_at >= ?", value)
-      end
-    end
-    expect(report.assets).not_to include(Entry.create!(:created_at => time - 1.day))
-    expect(report.assets).to include(Entry.create!(:created_at => time))
-  end
-
-
-  context "when date format is configured" do
-    around(:each) do |example|
-      with_date_format do
-        example.run
-      end
-    end
-
-    it "should have configurable date format" do
-      report = test_report(:created_at => "10/01/2013") do
-        scope  {Entry}
-        filter(:created_at, :date)
-      end
-      expect(report.created_at).to eq(Date.new(2013,10,01))
-    end
-
-    it "should support default explicit date" do
-      report = test_report(:created_at => Date.parse("2013-10-01")) do
-        scope  {Entry}
-        filter(:created_at, :date)
-      end
-      expect(report.created_at).to eq(Date.new(2013,10,01))
-    end
-  end
-
-
-  it "should automatically reverse Array if first more than last" do
-    report = test_report(:created_at => ["2013-01-01", "2012-01-01"]) do
-      scope  {Entry}
-      filter(:created_at, :date, :range => true)
-    end
-    expect(report.created_at).to eq([Date.new(2012, 01, 01), Date.new(2013, 01, 01)])
-  end
-  it "should automatically reverse Array if first more than last" do
-    report = test_report(:created_at => ["2013-01-01", "2012-01-01"]) do
-      scope  {Entry}
-      filter(:created_at, :date, :range => true)
-    end
-    expect(report.created_at).to eq([Date.new(2012, 01, 01), Date.new(2013, 01, 01)])
-  end
-
-  it "should nullify blank range" do
-    report = test_report(:created_at => [nil, nil]) do
-      scope  {Entry}
-      filter(:created_at, :date, :range => true)
-    end
-
-    expect(report.created_at).to eq(nil)
-  end
-
-  it "should properly format date in filter_value_as_string" do
-    with_date_format do
-      report = test_report(:created_at => "2012-01-02") do
-        scope  {Entry}
-        filter(:created_at, :date)
-      end
-      expect(report.filter_value_as_string(:created_at)).to eq("01/02/2012")
-    end
-  end
-
-end