datagrid 1.2.0 → 1.2.1

data/spec/datagrid/filters/date_time_filter_spec.rb

@@ -44,9 +44,9 @@ describe Datagrid::Filters::DateTimeFilter do
       scope { Entry }
       filter(:created_at, :datetime, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    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
@@ -57,9 +57,9 @@ describe Datagrid::Filters::DateTimeFilter do
       scope { Entry }
       filter(:created_at, :datetime, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should include(e3)
+    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
@@ -70,9 +70,9 @@ describe Datagrid::Filters::DateTimeFilter do
       scope { Entry }
       filter(:created_at, :datetime, :range => true)
     end
-    report.assets.should include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    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
@@ -84,9 +84,9 @@ describe Datagrid::Filters::DateTimeFilter do
       scope { Entry }
       filter(:created_at, :datetime, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
   it "should support invalid range" do
 
@@ -97,9 +97,9 @@ describe Datagrid::Filters::DateTimeFilter do
       scope { Entry }
       filter(:created_at, :datetime, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should_not include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).not_to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
 
@@ -110,8 +110,8 @@ describe Datagrid::Filters::DateTimeFilter do
         where("created_at >= ?", value)
       end
     end
-    report.assets.should_not include(Entry.create!(:created_at => 1.day.ago))
-    report.assets.should include(Entry.create!(:created_at => DateTime.tomorrow))
+    expect(report.assets).not_to include(Entry.create!(:created_at => 1.day.ago))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.tomorrow))
   end
 
 
@@ -127,7 +127,7 @@ describe Datagrid::Filters::DateTimeFilter do
         scope  {Entry}
         filter(:created_at, :datetime)
       end
-      report.created_at.should == DateTime.new(2013,10,01,1,0)
+      expect(report.created_at).to eq(DateTime.new(2013,10,01,1,0))
     end
 
     it "should support default explicit datetime" do
@@ -135,7 +135,7 @@ describe Datagrid::Filters::DateTimeFilter do
         scope  {Entry}
         filter(:created_at, :datetime)
       end
-      report.created_at.should == DateTime.new(2013,10,01,1,0)
+      expect(report.created_at).to eq(DateTime.new(2013,10,01,1,0))
     end
   end
 
@@ -145,6 +145,6 @@ describe Datagrid::Filters::DateTimeFilter do
       scope  {Entry}
       filter(:created_at, :datetime, :range => true)
     end
-    report.created_at.should == [DateTime.new(2012, 01, 01, 1, 0), DateTime.new(2013, 01, 01, 1, 0)]
+    expect(report.created_at).to eq([DateTime.new(2012, 01, 01, 1, 0), DateTime.new(2013, 01, 01, 1, 0)])
   end
 end

data/spec/datagrid/filters/dynamic_filter_spec.rb

@@ -11,112 +11,112 @@ describe Datagrid::Filters::DynamicFilter do
 
   it "should support = operation" do
     report.condition = [:name, "=", "hello"]
-    report.assets.should include(Entry.create!(:name => 'hello'))
-    report.assets.should_not include(Entry.create!(:name => 'bye'))
+    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"]
-    report.assets.should include(Entry.create!(:name => 'x'))
-    report.assets.should include(Entry.create!(:name => 'd'))
-    report.assets.should_not include(Entry.create!(:name => 'a'))
+    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, "=", ""]
-    report.assets.should include(Entry.create!(:name => 'hello'))
+    expect(report.assets).to include(Entry.create!(:name => 'hello'))
   end
 
   it "should support =~ operation on strings" do
     report.condition = [:name, "=~", "ell"]
-    report.assets.should include(Entry.create!(:name => 'hello'))
-    report.assets.should_not include(Entry.create!(:name => 'bye'))
+    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]
-    report.assets.should include(Entry.create!(:group_id => 2))
-    report.assets.should_not include(Entry.create!(:group_id => 1))
-    report.assets.should_not include(Entry.create!(:group_id => 3))
+    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]
-    report.assets.should include(Entry.create!(:group_id => 3))
-    report.assets.should_not include(Entry.create!(:group_id => 1))
+    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]
-    report.assets.should include(Entry.create!(:group_id => 1))
-    report.assets.should_not include(Entry.create!(:group_id => 3))
+    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']
-    report.assets.should include(Entry.create!(:group_id => 1))
-    report.assets.should include(Entry.create!(:group_id => 2))
-    report.assets.should_not include(Entry.create!(:group_id => 3))
+    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']
-    report.condition.should == [:group_id, "<=", nil]
+    expect(report.condition).to eq([:group_id, "<=", nil])
   end
 
   it "should nullify incorrect value for date" do
     report.condition = [:shipping_date, "<=", 'aa']
-    report.condition.should == [:shipping_date, "<=", nil]
+    expect(report.condition).to eq([:shipping_date, "<=", nil])
   end
 
   it "should nullify incorrect value for datetime" do
     report.condition = [:created_at, "<=", 'aa']
-    report.condition.should == [:created_at, "<=", nil]
+    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']
-    report.condition.should == [:created_at, "<=", Date.parse('1986-08-05')]
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-04 01:01:01')))
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
-    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 00:00:00')))
-    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
+    expect(report.condition).to eq([:created_at, "<=", Date.parse('1986-08-05')])
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-04 01:01:01')))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
+    expect(report.assets).not_to include(Entry.create!(:created_at => DateTime.parse('1986-08-06 00:00:00')))
+    expect(report.assets).not_to include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
   end
 
   it "should support date = operation by timestamp column" do
     report.condition = [:created_at, "=", '1986-08-05']
-    report.condition.should == [:created_at, "=", Date.parse('1986-08-05')]
-    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-04 23:59:59')))
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:01')))
+    expect(report.condition).to eq([:created_at, "=", Date.parse('1986-08-05')])
+    expect(report.assets).not_to include(Entry.create!(:created_at => DateTime.parse('1986-08-04 23:59:59')))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:01')))
     #TODO: investigate SQLite issue and uncomment this line
     #report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
-    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
+    expect(report.assets).not_to include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
   end
 
   it "should support date =~ operation by timestamp column" do
     report.condition = [:created_at, "=~", '1986-08-05']
-    report.condition.should == [:created_at, "=~", Date.parse('1986-08-05')]
-    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-04 23:59:59')))
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
-    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:01')))
+    expect(report.condition).to eq([:created_at, "=~", Date.parse('1986-08-05')])
+    expect(report.assets).not_to include(Entry.create!(:created_at => DateTime.parse('1986-08-04 23:59:59')))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:01')))
     #TODO: investigate SQLite issue and uncomment this line
     #report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
-    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
+    expect(report.assets).not_to include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
   end
 
   it "should support operations for invalid date" do
     report.condition = [:shipping_date, "<=", '1986-08-05']
-    report.assets.should include(Entry.create!(:shipping_date => '1986-08-04'))
-    report.assets.should include(Entry.create!(:shipping_date => '1986-08-05'))
-    report.assets.should_not include(Entry.create!(:shipping_date => '1986-08-06'))
+    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')]
-    report.assets.should include(Entry.create!(:shipping_date => '1986-08-04'))
-    report.assets.should include(Entry.create!(:shipping_date => '1986-08-05'))
-    report.assets.should_not include(Entry.create!(:shipping_date => '1986-08-06'))
+    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
 
 end

data/spec/datagrid/filters/enum_filter_spec.rb

@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Datagrid::Filters::EnumFilter do
 
   it "should support select option" do
-    test_report do
+    expect(test_report do
       scope {Entry}
       filter(:group_id, :enum, :select =>  [1,2] )
-    end.class.filter_by_name(:group_id).select.should == [1,2]
+    end.class.filter_by_name(:group_id).select).to eq([1,2])
   end
 
   it "should support select option as proc" do
-    test_report do
+    expect(test_report do
       scope {Entry}
       filter(:group_id, :enum, :select => proc { [1,2] })
-    end.class.filter_by_name(:group_id).select.should == [1,2]
+    end.class.filter_by_name(:group_id).select).to eq([1,2])
   end
 
   it "should support select option as proc with instace input" do
@@ -22,7 +22,7 @@ describe Datagrid::Filters::EnumFilter do
               filter(:group_id, :enum, :select => proc { |obj| obj.object_id })
             end.class
     instance = klass.new
-    klass.filter_by_name(:group_id).select(instance).should == instance.object_id
+    expect(klass.filter_by_name(:group_id).select(instance)).to eq(instance.object_id)
   end
   
   it "should initialize select option only on instanciation" do
@@ -43,7 +43,7 @@ describe Datagrid::Filters::EnumFilter do
       end
     end
 
-    report.filter_by_name(:group_id).select(report).should == [1,3,5]
+    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

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

data/spec/datagrid/filters/float_filter_spec.rb

@@ -9,7 +9,7 @@ describe Datagrid::Filters::FloatFilter do
       scope { Group }
       filter(:rating, :float)
     end
-    report.assets.should include(g1)
-    report.assets.should_not include(g2)
+    expect(report.assets).to include(g1)
+    expect(report.assets).not_to include(g2)
   end
 end

data/spec/datagrid/filters/integer_filter_spec.rb

@@ -10,9 +10,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry } 
       filter(:group_id, :integer)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
   it "should support integer range given as array argument" do
@@ -23,9 +23,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry } 
       filter(:group_id, :integer, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    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 integer argument" do
@@ -36,9 +36,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry } 
       filter(:group_id, :integer, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should_not include(e2)
-    report.assets.should include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).not_to include(e2)
+    expect(report.assets).to include(e3)
   end
 
   it "should support maximum integer argument" do
@@ -49,9 +49,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry } 
       filter(:group_id, :integer, :range => true)
     end
-    report.assets.should include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    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 integer interval" do
@@ -63,9 +63,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry } 
       filter(:group_id, :integer, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
   it "should support invalid range" do
 
@@ -76,9 +76,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry } 
       filter(:group_id, :integer, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should_not include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).not_to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
 
@@ -89,8 +89,8 @@ describe Datagrid::Filters::IntegerFilter do
         where("group_id >= ?", value)
       end
     end
-    report.assets.should_not include(Entry.create!(:group_id => 1))
-    report.assets.should include(Entry.create!(:group_id => 5))
+    expect(report.assets).not_to include(Entry.create!(:group_id => 1))
+    expect(report.assets).to include(Entry.create!(:group_id => 5))
   end
 
 
@@ -99,8 +99,8 @@ describe Datagrid::Filters::IntegerFilter do
       scope { Entry.joins(:group) } 
       filter(:rating, :integer, :range => true)
     end
-    report.assets.should_not include(Entry.create!(:group => Group.create!(:rating => 3)))
-    report.assets.should include(Entry.create!(:group => Group.create!(:rating => 5)))
+    expect(report.assets).not_to include(Entry.create!(:group => Group.create!(:rating => 3)))
+    expect(report.assets).to include(Entry.create!(:group => Group.create!(:rating => 5)))
   end
 
   it "should support multiple values" do
@@ -108,18 +108,18 @@ describe Datagrid::Filters::IntegerFilter do
       scope {Entry}
       filter(:group_id, :string, :multiple => true)
     end
-    report.assets.should include(Entry.create!( :group_id => 1))
-    report.assets.should include(Entry.create!( :group_id => 2))
-    report.assets.should_not include(Entry.create!( :group_id => 3))
+    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 support custom separator multiple values" do
     report = test_report(:group_id => "1|2") do
       scope {Entry}
       filter(:group_id, :string, :multiple => '|')
     end
-    report.assets.should include(Entry.create!( :group_id => 1))
-    report.assets.should include(Entry.create!( :group_id => 2))
-    report.assets.should_not include(Entry.create!( :group_id => 3))
+    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 support multiple values" do
@@ -127,9 +127,9 @@ describe Datagrid::Filters::IntegerFilter do
       scope {Entry}
       filter(:group_id, :string, :multiple => true)
     end
-    report.assets.should include(Entry.create!( :group_id => 1))
-    report.assets.should include(Entry.create!( :group_id => 2))
-    report.assets.should_not include(Entry.create!( :group_id => 3))
+    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 support custom separator multiple values" do
@@ -137,8 +137,8 @@ describe Datagrid::Filters::IntegerFilter do
       scope {Entry}
       filter(:group_id, :string, :multiple => '|')
     end
-    report.assets.should include(Entry.create!( :group_id => 1))
-    report.assets.should include(Entry.create!( :group_id => 2))
-    report.assets.should_not include(Entry.create!( :group_id => 3))
+    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
 end