datagrid 1.6.1 → 1.6.2

data/spec/datagrid/core_spec.rb

@@ -1,210 +0,0 @@
-require 'spec_helper'
-require "action_controller/metal/strong_parameters"
-
-describe Datagrid::Core do
-
-  context 'with 2 persisted entries' do
-    before { 2.times { Entry.create } }
-
-    let(:report_class) do
-      class ScopeTestReport
-        include Datagrid
-        scope { Entry.order("id desc") }
-      end
-      ScopeTestReport
-    end
-
-    describe '#scope' do
-      context 'in the class' do
-        let(:report) { report_class.new }
-
-        it { expect(report.scope.to_a.size).to eq(2) }
-        it { expect(report).to_not be_redefined_scope }
-
-        context "when redefined" do
-          it "should accept previous scope" do
-            module Ns83827
-              class TestGrid < ScopeTestReport
-                scope do |previous|
-                  previous.reorder("id asc")
-                end
-              end
-            end
-
-            expect(Ns83827::TestGrid.new.assets.order_values).to eq(["id asc"])
-          end
-        end
-
-      end
-
-      context 'changes scope on the fly' do
-        let(:report) do
-          report_class.new.tap do |r|
-            r.scope { Entry.limit(1)}
-          end
-        end
-
-        it { expect(report.scope.to_a.size).to eq(1) }
-        it { expect(report).to be_redefined_scope }
-      end
-
-      context 'overriding scope by initializer' do
-        let(:report) { report_class.new { Entry.limit(1) } }
-
-        it { expect(report).to be_redefined_scope }
-        it { expect(report.scope.to_a.size).to eq(1) }
-
-        context "reset scope to default" do
-          before do
-            report.reset_scope
-          end
-          it { expect(report.scope.to_a.size).to eq(2) }
-          it { expect(report).to_not be_redefined_scope }
-        end
-      end
-
-      context "appending scope by initializer " do
-        let(:report) { report_class.new {|scope| scope.limit(1)} }
-        it { expect(report.scope.to_a.size).to eq(1) }
-        it { expect(report.scope.order_values.size).to eq(1) }
-        it { expect(report).to be_redefined_scope }
-      end
-    end
-  end
-
-  describe "#inspect" do
-    it "should show all attribute values" do
-      class InspectTest
-        include Datagrid
-        scope {Entry}
-        filter(:created_at, :date, :range => true)
-        column(:name)
-      end
-
-      grid = InspectTest.new(:created_at => ['2014-01-01', '2014-08-05'], :descending => true, :order => 'name')
-      expect(grid.inspect).to eq('#<InspectTest order: :name, descending: true, created_at: [Wed, 01 Jan 2014, Tue, 05 Aug 2014]>')
-    end
-  end
-
-  describe "#==" do
-    class EqualTest
-      include Datagrid
-      scope {Entry}
-      filter(:created_at, :date)
-      column(:name)
-      column(:created_at)
-    end
-    it "work on empty objects" do
-      expect(EqualTest.new).to eq(EqualTest.new)
-    end
-    it "sees the difference on the filter value" do
-      expect(EqualTest.new(created_at: Date.yesterday)).to_not eq(EqualTest.new(created_at: Date.today))
-    end
-    it "sees the difference on order" do
-      expect(EqualTest.new(order: :created_at)).to_not eq(EqualTest.new(order: :name))
-    end
-    it "doesn't destinguish between String and Symbol order" do
-      expect(EqualTest.new(order: :created_at)).to eq(EqualTest.new(order: "created_at"))
-    end
-    it "checks for redefined scope" do
-      expect(EqualTest.new).to_not eq(EqualTest.new {|s| s.reorder(:name)})
-    end
-  end
-
-  describe 'dynamic helper' do
-    it "should work" do
-      grid = test_report do
-        scope {Entry}
-        column(:id)
-        dynamic {
-          column(:name)
-          column(:category)
-        }
-      end
-
-      expect(grid.columns.map(&:name)).to eq([:id, :name, :category])
-      expect(grid.class.columns.map(&:name)).to eq([:id])
-
-      expect(grid.column_by_name(:id)).not_to be_nil
-      expect(grid.column_by_name(:name)).not_to be_nil
-    end
-
-    it "has access to attributes" do
-      grid = test_report(:attribute_name => 'value') do
-        scope {Entry}
-        datagrid_attribute :attribute_name
-        dynamic {
-          value = attribute_name
-          column(:name) { value }
-        }
-      end
-
-      expect(grid.data_value(:name, Entry.create!)).to eq('value')
-    end
-
-    it "applies before instance scope" do
-      klass = test_report_class do
-        scope {Entry}
-        dynamic do
-          scope do |s|
-            s.limit(1)
-          end
-        end
-      end
-
-      grid = klass.new do |s|
-        s.limit(2)
-      end
-
-      expect(grid.assets.limit_value).to eq(2)
-    end
-  end
-
-  describe "ActionController::Parameters" do
-
-    let(:params) do
-      ::ActionController::Parameters.new(name: 'one')
-    end
-
-    it "permites all attributes by default" do
-      expect {
-        test_report(params) do
-          scope { Entry }
-          filter(:name)
-        end
-      }.to_not raise_error
-    end
-    it "doesn't permit attributes when forbidden_attributes_protection is set" do
-      expect {
-        test_report(params) do
-          scope { Entry }
-          self.forbidden_attributes_protection = true
-          filter(:name)
-        end
-      }.to raise_error(ActiveModel::ForbiddenAttributesError)
-    end
-    it "permits attributes when forbidden_attributes_protection is set and attributes are permitted" do
-      expect {
-        test_report(params.permit!) do
-          scope { Entry }
-          self.forbidden_attributes_protection = true
-          filter(:name)
-        end
-      }.to_not raise_error
-    end
-  end
-
-
-  describe ".query_param" do
-    it "works" do
-      grid = test_report(name: 'value') do
-        scope {Entry}
-        filter(:name)
-        def param_name
-          'grid'
-        end
-      end
-      expect(grid.query_params).to eq({grid: {name: 'value'}})
-    end
-  end
-end

data/spec/datagrid/drivers/active_record_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Drivers::ActiveRecord do
-
-  describe ".match?" do
-    subject { described_class }
-
-    it {should be_match(Entry)}
-    it {should be_match(Entry.where(:id => 1))}
-    it {should_not be_match(MongoidEntry)}
-  end
-
-  it "should convert any scope to AR::Relation" do
-    expect(subject.to_scope(Entry)).to be_a(ActiveRecord::Relation)
-    expect(subject.to_scope(Entry.limit(5))).to be_a(ActiveRecord::Relation)
-    expect(subject.to_scope(Group.create!.entries)).to be_a(ActiveRecord::Relation)
-  end
-
-  it "should support append_column_queries" do
-    scope = subject.append_column_queries(Entry.where({}), [Datagrid::Columns::Column.new(test_report_class, :sum_group_id, 'sum(entries.group_id)')])
-    expect(scope.to_sql.strip).to eq('SELECT "entries".*, sum(entries.group_id) AS sum_group_id FROM "entries"')
-  end
-
-  describe "Arel" do
-    subject do
-      test_report(:order => :test, :descending => true) do
-        scope { Entry }
-        column(:test, order: Entry.arel_table[:group_id].count)
-      end.assets
-    end
-
-    it "should support ordering by Arel columns" do
-      expect(subject.to_sql.strip).to include 'ORDER BY COUNT("entries"."group_id") DESC'
-    end
-  end
-
-  describe "gotcha #datagrid_where_by_timestamp" do
-
-    subject do
-      test_report(created_at: 10.days.ago..5.days.ago) do
-        scope {Entry}
-
-        filter(:created_at, :date, range: true) do |value, scope, grid|
-          scope.joins(:group).datagrid_where_by_timestamp("groups.created_at", value)
-        end
-      end.assets
-    end
-    it "includes object created in proper range" do
-      expect(subject).to include(
-        Entry.create!(group: Group.create!(created_at: 7.days.ago)),
-      )
-    end
-
-    it "excludes object created before the range" do
-      expect(subject).to_not include(
-        Entry.create!(created_at: 7.days.ago, group: Group.create!(created_at: 11.days.ago)),
-      )
-    end
-    it "excludes object created after the range" do
-      expect(subject).to_not include(
-        Entry.create!(created_at: 7.days.ago, group: Group.create!(created_at: 4.days.ago)),
-      )
-    end
-  end
-
-  describe "batches usage" do
-
-    it "should be incompatible with scope with limit" do
-      report = test_report do
-        scope {Entry.limit(5)}
-        self.batch_size = 20
-        column(:id)
-      end
-      expect { report.data }.to raise_error(Datagrid::ConfigurationError)
-    end
-  end
-
-
-end

data/spec/datagrid/drivers/array_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Drivers::Array do
-
-  describe ".match?" do
-    subject { described_class }
-
-    it {should be_match(Array.new)}
-    it {should_not be_match({})}
-  end
-  
-  describe "api" do
-  
-    class ArrayGrid
-      class User < Struct.new(:name, :age); end
-      include Datagrid
-      scope do
-        []
-      end
-
-      filter(:name)
-      filter(:age, :integer, :range => true)
-
-      column(:name)
-      column(:age)
-    end
-
-    let(:first) { ArrayGrid::User.new("Vasya", 15) }
-    let(:second) { ArrayGrid::User.new("Petya", 12) }
-    let(:third) { ArrayGrid::User.new("Vova", 13) }
-
-    subject do
-      ArrayGrid.new(
-        defined?(_attributes) ? _attributes : {}
-      ).scope do
-        [ first, second, third ]
-      end
-    end
-  
-          
-    describe '#assets' do
-      subject { super().assets }
-      describe '#size' do
-        subject { super().size }
-        it {should == 3}
-      end
-    end
-
-    describe '#rows' do
-      subject { super().rows }
-      it {should == [["Vasya", 15], ["Petya", 12], ["Vova", 13]]}
-    end
-
-    describe '#header' do
-      subject { super().header }
-      it {should ==[ "Name", "Age"]}
-    end
-      
-    describe '#data' do
-      subject { super().data }
-      it {should == [[ "Name", "Age"], ["Vasya", 15], ["Petya", 12], ["Vova", 13]]}
-    end
-      
-      
-    describe "when some filters specified" do
-      let(:_attributes) { {:age => [12,14]} }
-
-      describe '#assets' do
-        subject { super().assets }
-        it {should_not include(first)}
-      end
-
-      describe '#assets' do
-        subject { super().assets }
-        it {should include(second)}
-      end
-
-      describe '#assets' do
-        subject { super().assets }
-        it {should include(third)}
-      end
-    end
-      
-    describe "when reverse ordering is specified" do
-      let(:_attributes) { {:order => :name, :descending => true} }
-
-      describe '#assets' do
-        subject { super().assets }
-        it {should == [third, first, second]}
-      end
-    end
-
-  end
-    describe "when using enumerator scope" do
-
-      it "should work fine" do
-        grid = test_report(to_enum: true) do
-          scope {[]}
-          filter(:to_enum, :boolean) do |_, scope|
-            scope.to_enum
-          end
-        end
-        grid.assets.should_not be_any
-      end
-    end
-end

data/spec/datagrid/drivers/mongo_mapper_spec.rb

@@ -1,101 +0,0 @@
-require "spec_helper"
-
-describe Datagrid::Drivers::MongoMapper, :mongomapper do
-
-  if defined?(MongoMapper)
-    describe ".match?" do
-
-      subject { described_class }
-
-      it {should be_match(MongoMapperEntry)}
-      # MongoMapper doesn't have a scoped method, instead it has a query method which returns a Plucky::Query object
-      it {should be_match(MongoMapperEntry.query)}
-      it {should_not be_match(Entry.where(:id => 1))}
-
-    end
-    describe "api" do
-
-      subject do
-        MongoMapperGrid.new(
-          defined?(_attributes) ? _attributes : {}
-        )
-      end
-
-      let!(:first) do
-        MongoMapperEntry.create!(
-          :group_id => 2,
-          :name => "Main First",
-          :disabled => false
-        )
-      end
-      let!(:second) do
-        MongoMapperEntry.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 }
-          it {should_not include(first)}
-        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 { MongoMapperEntry }
-            column(:test)
-            end.assets
-        }.to raise_error(Datagrid::OrderUnsupported)
-          end
-      end
-    end
-  end