arel_extensions 1.6.0 → 2.0.0.rc3

data/test/real_db_test.rb

@@ -6,41 +6,36 @@ $:.unshift "#{File.dirname(__FILE__)}../../lib"
 require 'arel_extensions'
 
 def setup_db
-  ActiveRecord::Base.configurations = ConfigLoader.load('test/database.yml')
+  ActiveRecord::Base.configurations = YAML.load_file('test/database.yml')
   ActiveRecord::Base.establish_connection(ENV['DB'].try(:to_sym) || (RUBY_PLATFORM == 'java' ? :"jdbc-sqlite" : :sqlite))
-  if ACTIVE_RECORD_VERSION >= V7_0
-    ActiveRecord.default_timezone = :utc
-  else
-    ActiveRecord::Base.default_timezone = :utc
-  end
+  ActiveRecord::Base.default_timezone = :utc
   @cnx = ActiveRecord::Base.connection
-  if /sqlite/i.match?(ActiveRecord::Base.connection.adapter_name)
+  if ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
     $sqlite = true
     db = @cnx.raw_connection
     if !$load_extension_disabled
       begin
         db.enable_load_extension(1)
-        db.load_extension('/usr/lib/sqlite3/pcre.so')
-        db.load_extension('/usr/lib/sqlite3/extension-functions.so')
+        db.load_extension("/usr/lib/sqlite3/pcre.so")
+        db.load_extension("/usr/lib/sqlite3/extension-functions.so")
         db.enable_load_extension(0)
       rescue => e
         $load_extension_disabled = true
-        $stderr << "cannot load extensions #{e.inspect}\n"
+        $stderr << "can not load extensions #{e.inspect}\n"
       end
     end
-    # function find_in_set
-    db.create_function('find_in_set', 1) do |func, value1, value2|
+    #function find_in_set
+    db.create_function("find_in_set", 1) do |func, value1, value2|
       func.result = value1.index(value2)
     end
   end
-  @cnx.drop_table(:users) rescue nil
+  @cnx.drop_table(:users) rescue nil 
   @cnx.create_table :users do |t|
-    t.column :age, :integer
+      t.column :age, :integer
       t.column :name, :string
       t.column :created_at, :date
       t.column :updated_at, :date
       t.column :score, :decimal
-      t.column :updated_at, :datetime
   end
 end
 
@@ -49,22 +44,23 @@ def teardown_db
 end
 
 class User < ActiveRecord::Base
+
 end
 
 class ListTest < Minitest::Test
+
   def setup
-    d = Date.new(2016, 05, 23)
-    dt = Time.new(2016, 05, 23, 12, 34, 56)
+    d = Date.new(2016,05,23)
     setup_db
-    User.create age: 5, name: 'Lucas', created_at: d, score: 20.16
-    User.create age: 15, name: 'Sophie', created_at: d, score: 20.16
-    User.create age: 20, name: 'Camille', created_at: d, score: 20.16
-    User.create age: 21, name: 'Arthur', created_at: d, score: 65.62, updated_at: dt
-    u = User.create age: 23, name: 'Myung', created_at: d, score: 20.16
-    @myung = User.where(id: u.id)
-    User.create age: 25, name: 'Laure', created_at: d, score: 20.16
-    User.create age: nil, name: 'Test', created_at: d, score: 1.62
-    User.create age: -0, name: 'Negatif', created_at: d, score: 0.17
+    User.create :age => 5, :name => "Lucas", :created_at => d , :score => 20.16
+    User.create :age => 15, :name => "Sophie", :created_at => d, :score => 20.16
+    User.create :age => 20, :name => "Camille", :created_at => d, :score => 20.16
+    User.create :age => 21, :name => "Arthur", :created_at => d, :score => 65.62
+    u = User.create :age => 23, :name => "Myung", :created_at => d, :score => 20.16
+    @myung = User.where(:id => u.id)
+    User.create :age => 25, :name => "Laure", :created_at => d, :score =>20.16
+    User.create :age =>nil, :name => "Test", :created_at => d, :score => 1.62
+    User.create :age =>-0, :name => "Negatif", :created_at => d, :score => 0.17
   end
 
   def teardown
@@ -72,136 +68,133 @@ class ListTest < Minitest::Test
   end
 
   def test_abs
-    assert_equal 0, User.where(User.arel_table[:name].eq('Negatif')).select((User.arel_table[:age].abs).as('res')).first.res
-    assert_equal 14, User.where(User.arel_table[:name].eq('Laure')).select(((User.arel_table[:age] - 39).abs).as('res')).first.res
+    assert_equal 0,User.where(User.arel_table[:name].eq("Negatif")).select((User.arel_table[:age].abs).as("res")).first.res
+    assert_equal 14,User.where(User.arel_table[:name].eq("Laure")).select(((User.arel_table[:age] - 39).abs).as("res")).first.res
   end
 
   def test_ceil
     if !$sqlite || !$load_extension_disabled
-      assert_equal 1, User.where(User.arel_table[:name].eq('Negatif')).select((User.arel_table[:score].ceil).as('res')).first.res
-      assert_equal 66, User.where(User.arel_table[:name].eq('Arthur')).select((User.arel_table[:score].ceil).as('res')).first.res
+      assert_equal 1,User.where(User.arel_table[:name].eq("Negatif")).select((User.arel_table[:score].ceil).as("res")).first.res
+      assert_equal 66,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:score].ceil).as("res")).first.res
     end
   end
 
   def test_coalesce
-    if /pgsql/i.match?(@cnx.adapter_name)
-      assert_equal 100, User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].coalesce(100)).as('res')).first.res
-        assert_equal 'Camille', User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].coalesce('Null', 'default')).as('res')).first.res
+    if @cnx.adapter_name =~ /pgsql/i
+        assert_equal 100,User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].coalesce(100)).as("res")).first.res
+        assert_equal "Camille",User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].coalesce("Null","default")).as("res")).first.res
     else
-      assert_equal 'Camille', User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].coalesce('Null', 20)).as('res')).first.res
-      assert_equal 20, User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].coalesce(nil, 20)).as('res')).first.res
+      assert_equal "Camille",User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].coalesce("Null",20)).as("res")).first.res
+      assert_equal 20,User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].coalesce(nil,20)).as("res")).first.res
     end
   end
 
-  def test_comparator
-    assert_equal 2, User.where(User.arel_table[:age] < 6).count
-    assert_equal 2, User.where(User.arel_table[:age] <= 10).count
-    assert_equal 3, User.where(User.arel_table[:age] > 20).count
-    assert_equal 4, User.where(User.arel_table[:age] >= 20).count
-    assert_equal 1, User.where(User.arel_table[:age] > 5).where(User.arel_table[:age] < 20).count
-  end
-
-  def test_date_date_comparator
-    d = Date.new(2016, 05, 24) #after created_at in db
-    assert_equal 8, User.where(User.arel_table[:age] < d).count
-    assert_equal 0, User.where(User.arel_table[:age] > d).count
-    assert_equal 0, User.where(User.arel_table[:age] == d).count
-    d = Date.new(2016, 05, 23)
-    assert_equal 8, User.where(User.arel_table[:age] == d).count
-    dt = Time.new(2016, 05, 23, 12, 35, 00) #after updated_at in db
-    assert_equal 1, User.where(User.arel_table[:update_at] < dt).count
-    assert_equal 0, User.where(User.arel_table[:update_at] > dt).count
+  def test_Comparator
+    assert_equal 2,User.where(User.arel_table[:age] < 6 ).count
+    assert_equal 2,User.where(User.arel_table[:age] <=10 ).count
+    assert_equal 3,User.where(User.arel_table[:age] > 20 ).count
+    assert_equal 4,User.where(User.arel_table[:age] >=20 ).count
+    assert_equal 1,User.where(User.arel_table[:age] > 5 ).where(User.arel_table[:age] < 20 ).count
   end
 
   def test_date_duration
-    # Year
-    assert_equal 2016, User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:created_at].year).as('res')).first.res.to_i
-    assert_equal 0, User.where(User.arel_table[:created_at].year.eq('2012')).count
-    # Month
-    assert_equal 5, User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:created_at].month).as('res')).first.res.to_i
-    assert_equal 8, User.where(User.arel_table[:created_at].month.eq('05')).count
-    # Week
-    assert_equal 21, User.where(User.arel_table[:name].eq('Arthur')).select((User.arel_table[:created_at].week).as('res')).first.res.to_i
-    assert_equal 8, User.where(User.arel_table[:created_at].month.eq('05')).count
-    # Day
-    assert_equal 23, User.where(User.arel_table[:name].eq('Laure')).select((User.arel_table[:created_at].day).as('res')).first.res.to_i
-    assert_equal 0, User.where(User.arel_table[:created_at].day.eq('05')).count
+    #Year
+    assert_equal 2016,User.where(User.arel_table[:name].eq("Lucas")).select((User.arel_table[:created_at].year).as("res")).first.res.to_i
+    assert_equal 0,User.where(User.arel_table[:created_at].year.eq("2012")).count
+    #Month
+    assert_equal 5,User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:created_at].month).as("res")).first.res.to_i
+    assert_equal 8,User.where(User.arel_table[:created_at].month.eq("05")).count
+    #Week
+    assert_equal 21,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:created_at].week).as("res")).first.res.to_i
+    assert_equal 8,User.where(User.arel_table[:created_at].month.eq("05")).count
+    #Day
+    assert_equal 23,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:created_at].day).as("res")).first.res.to_i
+    assert_equal 0,User.where(User.arel_table[:created_at].day.eq("05")).count
   end
 
+
+
   def test_length
-    assert_equal 7, User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].length).as('res')).first.res
-    assert_equal 5, User.where(User.arel_table[:name].eq('Laure')).select((User.arel_table[:name].length).as('res')).first.res
+    assert_equal 7,User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].length).as("res")).first.res
+    assert_equal 5,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:name].length).as("res")).first.res
   end
 
   def test_locate
     if !$sqlite || !$load_extension_disabled
-      assert_equal 1, User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].locate('C')).as('res')).first.res
-      assert_equal 0, User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].locate('z')).as('res')).first.res
-      assert_equal 5, User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].locate('s')).as('res')).first.res
+      assert_equal 1, User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].locate("C")).as("res")).first.res
+      assert_equal 0, User.where(User.arel_table[:name].eq("Lucas")).select((User.arel_table[:name].locate("z")).as("res")).first.res
+      assert_equal 5, User.where(User.arel_table[:name].eq("Lucas")).select((User.arel_table[:name].locate("s")).as("res")).first.res
     end
   end
 
   def test_isnull
-    if /pgsql/i.match?(ActiveRecord::Base.connection.adapter_name)
-      assert_equal 100, User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].isnull(100)).as('res')).first.res
+    if ActiveRecord::Base.connection.adapter_name =~ /pgsql/i
+      assert_equal 100,User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].isnull(100)).as("res")).first.res
     else
-      assert_equal 'default', User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].isnull('default')).as('res')).first.res
-      assert_equal 'Test', User.where((User.arel_table[:age].isnull('default')).eq('default')).select(User.arel_table[:name]).first.name.to_s
+      assert_equal "default",User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].isnull('default')).as("res")).first.res
+      assert_equal "Test",User.where((User.arel_table[:age].isnull('default')).eq('default')).select(User.arel_table[:name]).first.name.to_s
     end
   end
 
+
   def test_floor
     if !$sqlite || !$load_extension_disabled
-      assert_equal 0, User.where(User.arel_table[:name].eq('Negatif')).select((User.arel_table[:score].floor).as('res')).first.res
-      assert_equal 65, User.where(User.arel_table[:name].eq('Arthur')).select((User.arel_table[:score].floor).as('res')).first.res
+      assert_equal 0,User.where(User.arel_table[:name].eq("Negatif")).select((User.arel_table[:score].floor).as("res")).first.res
+      assert_equal 65,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:score].floor).as("res")).first.res
     end
   end
 
+
   def test_findinset
     db = ActiveRecord::Base.connection.raw_connection
-    assert_equal 3, db.get_first_value("select find_in_set(name,'i') from users where name = 'Camille'")
-    assert_equal '', db.get_first_value("select find_in_set(name,'p') from users where name = 'Camille'").to_s
-    # number
-    # assert_equal 1,User.select(User.arel_table[:name] & ("l")).count
-    # assert_equal 3,(User.select(User.arel_table[:age] & [5,15,20]))
-    # string
+    assert_equal 3,db.get_first_value( "select find_in_set(name,'i') from users where name = 'Camille'" )
+    assert_equal "",db.get_first_value( "select find_in_set(name,'p') from users where name = 'Camille'" ).to_s
+    #number
+    #assert_equal 1,User.select(User.arel_table[:name] & ("l")).count
+    #assert_equal 3,(User.select(User.arel_table[:age] & [5,15,20]))
+    #string
   end
 
+
   def test_math_plus
-    d = Date.new(1997, 06, 15)
-    # Concat String
-    assert_equal 'SophiePhan', User.where(User.arel_table[:name].eq('Sophie')).select((User.arel_table[:name] + 'Phan').as('res')).first.res
-    assert_equal 'Sophie2', User.where(User.arel_table[:name].eq('Sophie')).select((User.arel_table[:name] + 2).as('res')).first.res
-    assert_equal 'Sophie1997-06-15', User.where(User.arel_table[:name].eq('Sophie')).select((User.arel_table[:name] + d).as('res')).first.res
-    assert_equal 'Sophie15', User.where(User.arel_table[:name].eq('Sophie')).select((User.arel_table[:name] + User.arel_table[:age]).as('res')).first.res
-    assert_equal 'SophieSophie', User.where(User.arel_table[:name].eq('Sophie')).select((User.arel_table[:name] + User.arel_table[:name]).as('res')).first.res
-    assert_equal 'Sophie2016-05-23', User.where(User.arel_table[:name].eq('Sophie')).select((User.arel_table[:name] + User.arel_table[:created_at]).as('res')).first.res
-    # concat Integer
+    d = Date.new(1997,06,15)
+    #Concat String
+    assert_equal "SophiePhan",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + "Phan").as("res")).first.res
+    assert_equal "Sophie2",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + 2 ).as("res")).first.res
+    assert_equal "Sophie1997-06-15",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + d).as("res")).first.res
+    assert_equal "Sophie15",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + User.arel_table[:age]).as("res")).first.res
+    assert_equal "SophieSophie",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + User.arel_table[:name]).as("res")).first.res
+    assert_equal "Sophie2016-05-23",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + User.arel_table[:created_at]).as("res")).first.res
+    #concat Integer
     assert_equal 1, User.where((User.arel_table[:age] + 10).eq(33)).count
-    assert_equal 1, User.where((User.arel_table[:age] + '1').eq(6)).count
+    assert_equal 1, User.where((User.arel_table[:age] + "1").eq(6)).count
     assert_equal 1, User.where((User.arel_table[:age] + User.arel_table[:age]).eq(10)).count
-    # concat Date
-    #    puts((User.arel_table[:created_at] + 1).as("res").to_sql.inspect)
-    assert_equal '2016-05-24', @myung.select((User.arel_table[:created_at] + 1).as('res')).first.res.to_date.to_s
-    assert_equal '2016-05-25', @myung.select((User.arel_table[:created_at] + 2.day).as('res')).first.res.to_date.to_s
+    #concat Date
+#    puts((User.arel_table[:created_at] + 1).as("res").to_sql.inspect)
+    assert_equal "2016-05-24", @myung.select((User.arel_table[:created_at] + 1).as("res")).first.res.to_date.to_s
+    assert_equal "2016-05-25", @myung.select((User.arel_table[:created_at] + 2.day).as("res")).first.res.to_date.to_s
   end
 
+
   def test_math_moins
-    d = Date.new(2016, 05, 20)
-    # Datediff
-    assert_equal 8, User.where((User.arel_table[:created_at] - User.arel_table[:created_at]).eq(0)).count
-    assert_equal 3, User.where(User.arel_table[:name].eq('Laure')).select((User.arel_table[:created_at] - d).as('res')).first.res.abs.to_i
-    # Substraction
+    d = Date.new(2016,05,20)
+    #Datediff
+    assert_equal 8,User.where((User.arel_table[:created_at] - User.arel_table[:created_at]).eq(0)).count
+    assert_equal 3,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:created_at] - d).as("res")).first.res.abs.to_i
+    #Substraction
     assert_equal 0, User.where((User.arel_table[:age] - 10).eq(50)).count
-    assert_equal 0, User.where((User.arel_table[:age] - '10').eq(50)).count
+    assert_equal 0, User.where((User.arel_table[:age] - "10").eq(50)).count
   end
 
+
+
   def test_rand
-    assert_equal 5, User.where(User.arel_table[:score].eq(20.16)).select(User.arel_table[:id]).order(Arel.rand).take(50).count
-    # test_alias  :random  :rand
-    assert_equal 8, User.select(User.arel_table[:name]).order(Arel.rand).take(50).count
+    assert_equal 5,User.where(User.arel_table[:score].eq(20.16)).select(User.arel_table[:id]).order(Arel.rand).take(50).count
+    #test_alias  :random  :rand
+    assert_equal 8,User.select(User.arel_table[:name]).order(Arel.rand).take(50).count
   end
 
+
   def test_regexp_not_regex
     if !$sqlite || !$load_extension_disabled
       assert_equal 1, User.where(User.arel_table[:name] =~ '^M').count
@@ -210,41 +203,45 @@ class ListTest < Minitest::Test
   end
 
   def test_replace
-    assert_equal 'LucaX', User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].replace('s', 'X')).as('res')).first.res
-    assert_equal 'replace', User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].replace(User.arel_table[:name], 'replace')).as('res')).first.res
+    assert_equal "LucaX",User.where(User.arel_table[:name].eq("Lucas")).select(((User.arel_table[:name]).replace("s","X")).as("res")).first.res
+    assert_equal "replace",User.where(User.arel_table[:name].eq("Lucas")).select(((User.arel_table[:name]).replace(User.arel_table[:name],"replace")).as("res")).first.res
   end
 
+
   def test_round
     assert_equal 1, User.where(((User.arel_table[:age]).round(0)).eq(5.0)).count
     assert_equal 0, User.where(((User.arel_table[:age]).round(-1)).eq(6.0)).count
   end
 
+
   def test_Soundex
     if !$sqlite || !$load_extension_disabled
-      assert_equal 'C540', User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].soundex).as('res')).first.res.to_s
-      assert_equal 8, User.where((User.arel_table[:name].soundex).eq(User.arel_table[:name].soundex)).count
+      assert_equal "C540",User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].soundex).as("res")).first.res.to_s
+      assert_equal 8,User.where((User.arel_table[:name].soundex).eq(User.arel_table[:name].soundex)).count
     end
   end
 
   def test_Sum
-    # .take(50) because of limit by ORDER BY
-    assert_equal 110, User.select((User.arel_table[:age].sum + 1).as('res')).take(50).first.res
-    assert_equal 218, User.select((User.arel_table[:age].sum + User.arel_table[:age].sum).as('res')).take(50).first.res
-    assert_equal 327, User.select(((User.arel_table[:age] * 3).sum).as('res')).take(50).first.res
-    assert_equal 2245, User.select(((User.arel_table[:age] * User.arel_table[:age]).sum).as('res')).take(50).first.res
+    #.take(50) because of limit by ORDER BY
+    assert_equal 110,User.select((User.arel_table[:age].sum + 1).as("res")).take(50).first.res
+    assert_equal 218,User.select((User.arel_table[:age].sum + User.arel_table[:age].sum).as("res")).take(50).first.res
+    assert_equal 327,User.select(((User.arel_table[:age] * 3).sum).as("res")).take(50).first.res
+    assert_equal 2245,User.select(((User.arel_table[:age] * User.arel_table[:age]).sum).as("res")).take(50).first.res
   end
 
+
   def test_trim
-    assert_equal 'Myun', User.where(User.arel_table[:name].eq('Myung')).select(User.arel_table[:name].rtrim('g').as('res')).first.res
-    assert_equal 'yung', User.where(User.arel_table[:name].eq('Myung')).select(User.arel_table[:name].ltrim('M').as('res')).first.res
-    assert_equal 'yung', User.where(User.arel_table[:name].eq('Myung')).select((User.arel_table[:name] + 'M').trim('M').as('res')).first.res
-    assert_equal '', User.where(User.arel_table[:name].eq('Myung')).select(User.arel_table[:name].rtrim(User.arel_table[:name]).as('res')).first.res
+    assert_equal "Myun",User.where(User.arel_table[:name].eq("Myung")).select(User.arel_table[:name].rtrim("g").as("res")).first.res
+    assert_equal "yung",User.where(User.arel_table[:name].eq("Myung")).select(User.arel_table[:name].ltrim("M").as("res")).first.res
+    assert_equal "yung",User.where(User.arel_table[:name].eq("Myung")).select((User.arel_table[:name] + "M").trim("M").as("res")).first.res
+    assert_equal "",User.where(User.arel_table[:name].eq("Myung")).select(User.arel_table[:name].rtrim(User.arel_table[:name]).as("res")).first.res
 
   end
 
   def test_wday
-    d = Date.new(2016, 06, 26)
-      assert_equal 1, User.where(User.arel_table[:name].eq('Myung')).select((User.arel_table[:created_at].wday).as('res')).first.res.to_i
-      assert_equal 0, User.select(d.wday).as('res').first.to_i
+      d = Date.new(2016,06,26)
+      assert_equal 1,User.where(User.arel_table[:name].eq("Myung")).select((User.arel_table[:created_at].wday).as("res")).first.res.to_i
+      assert_equal 0,User.select(d.wday).as("res").first.to_i
   end
+
 end

data/test/support/fake_record.rb

@@ -1,5 +1,3 @@
-require 'arel_extensions/constants'
-
 module FakeRecord
   class Column < Struct.new(:name, :type)
   end
@@ -9,7 +7,7 @@ module FakeRecord
     attr_accessor :visitor
 
     def initialize(visitor = nil)
-      @tables = %w{users photos developers products}
+      @tables = %w{ users photos developers products}
       @columns = {
         'users' => [
           Column.new('id', :integer),
@@ -68,7 +66,7 @@ module FakeRecord
     end
 
     def in_clause_length
-      10_000
+      6
     end
 
     def quote thing, column = nil
@@ -107,7 +105,7 @@ module FakeRecord
     attr_reader :spec, :connection
 
     def initialize
-      @spec = Spec.new({adapter: 'america'})
+      @spec = Spec.new(:adapter => 'america')
       @connection = Connection.new
       @connection.visitor = Arel::Visitors::ToSql.new(connection)
     end
@@ -147,11 +145,5 @@ module FakeRecord
     def connection
       connection_pool.connection
     end
-
-    if ArelExtensions::ACTIVE_RECORD_VERSION >= ArelExtensions::V7_2
-      def with_connection(*args, **kwargs, &block)
-        connection_pool.with_connection(*args, **kwargs, &block)
-      end
-    end
   end
 end

data/test/test_comparators.rb

@@ -1,8 +1,10 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module Nodes
+
     describe ArelExtensions::Comparators do
+
       before do
         @conn = FakeRecord::Base.new
         Arel::Table.engine = @conn
@@ -17,26 +19,27 @@ module ArelExtensions
         @visitor.accept(node, Arel::Collectors::SQLString.new).value
       end
 
-      it '< is equal lt' do
-        _(compile(@table[:id] < 10)).must_be_like('"users"."id" < 10')
+      it "< is equal lt" do
+        compile(@table[:id] < 10).must_be_like('"users"."id" < 10')
       end
-
-      it '<= is equal lteq' do
-        _(compile(@table[:id] <= 10)).must_be_like('"users"."id" <= 10')
+      
+      it "<= is equal lteq" do
+        compile(@table[:id] <= 10).must_be_like('"users"."id" <= 10')
       end
 
-      it '> is equal gt' do
-        _(compile(@table[:id] > 10)).must_be_like('"users"."id" > 10')
+      it "> is equal gt" do
+        compile(@table[:id] > 10).must_be_like('"users"."id" > 10')
       end
 
-      it '< is equal gteq' do
-        _(compile(@table[:id] >= 10)).must_be_like('"users"."id" >= 10')
+      it "< is equal gteq" do
+        compile(@table[:id] >= 10).must_be_like('"users"."id" >= 10')
       end
 
-      it 'should compare with dates' do
-        _(compile(@table[:created_at] >= Date.new(2016, 3, 31)))
-          .must_be_like %{"users"."created_at" >= '2016-03-31'}
+      it "should compare with dates" do
+        compile(@table[:created_at] >= Date.new(2016, 3, 31)).must_be_like %{"users"."created_at" >= '2016-03-31'}
       end
+
     end
+
   end
-end
+end

data/test/visitors/test_bulk_insert_oracle.rb

@@ -1,4 +1,4 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module BulkInsertOracle
@@ -7,28 +7,28 @@ module ArelExtensions
         @conn = FakeRecord::Base.new
         @visitor = Arel::Visitors::Oracle.new @conn.connection
         @table = Arel::Table.new(:users)
-        @cols = %w[name comments created_at]
+        @cols = ['name', 'comments', 'created_at']
         @data = [
-          %w[nom1 sdfdsfdsfsdf 2016-01-01],
-          %w[nom2 sdfdsfdsfsdf 2016-01-01]
+        	['nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	['nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
       def compile node
-        if AREL_VERSION > V5
+        if Arel::VERSION.to_i > 5
           @visitor.accept(node, Arel::Collectors::SQLString.new).value
         else
           @visitor.accept(node)
         end
       end
 
-      it 'should import large set of data in Oracle' do
-        insert_manager = AREL_VERSION > V6 ? Arel::InsertManager.new.into(@table) : Arel::InsertManager.new(@conn).into(@table)
-        insert_manager.bulk_insert(@cols, @data)
-        _(compile(insert_manager.ast))
-          .must_be_like %Q[INSERT INTO "users" ("name", "comments", "created_at")
-                        ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
+      it "should import large set of data in Oracle" do
+        insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
+      	insert_manager.bulk_insert(@cols, @data)
+      	sql = compile(insert_manager.ast)
+      	sql.must_be_like %Q[INSERT INTO "users" ("name", "comments", "created_at") ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
       end
-    end
+
+	  end
   end
 end

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -1,35 +1,36 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module BulkInsertSQLlite
+
     describe 'the sqlite visitor can bulk insert' do
       before do
         @conn = FakeRecord::Base.new
         @visitor = Arel::Visitors::SQLite.new @conn.connection
         @table = Arel::Table.new(:users)
         Arel::Table.engine = @conn
-        @cols = %w[id name comments created_at]
+        @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
-          [23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'],
-          [25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
-
+      
       def compile node
-        if AREL_VERSION > V5
+        if Arel::VERSION.to_i > 5
           @visitor.accept(node, Arel::Collectors::SQLString.new).value
         else
           @visitor.accept(node)
         end
       end
 
-      it 'should import large set of data' do
-        insert_manager = AREL_VERSION > V6 ? Arel::InsertManager.new.into(@table) : Arel::InsertManager.new(@conn).into(@table)
+      it "should import large set of data" do
+        insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
         insert_manager.bulk_insert(@cols, @data)
-        _(compile(insert_manager.ast))
-          .must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at")
-                         SELECT 23 AS 'id', 'nom1' AS 'name', 'sdfdsfdsfsdf' AS 'comments', '2016-01-01' AS 'created_at' UNION ALL SELECT 25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
+        sql = compile(insert_manager.ast)
+    	  sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") SELECT 23 AS 'id', 'nom1' AS 'name', 'sdfdsfdsfsdf' AS 'comments', '2016-01-01' AS 'created_at' UNION ALL SELECT 25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
       end
-    end
+
+	  end
   end
-end
+end

data/test/visitors/test_bulk_insert_to_sql.rb

@@ -1,4 +1,4 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module BulkInsertToSql
@@ -8,10 +8,10 @@ module ArelExtensions
         Arel::Table.engine = @conn
         @visitor = Arel::Visitors::ToSql.new @conn.connection
         @table = Arel::Table.new(:users)
-        @cols = %w[id name comments created_at]
+        @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
-          [23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'],
-          [25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
@@ -24,12 +24,14 @@ module ArelExtensions
       end
 
 
-      it 'should import large set of data using ToSql' do
-        insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new.into(@table) : Arel::InsertManager.new(@conn).into(@table)
-        insert_manager.bulk_insert(@cols, @data)
-        _(compile(insert_manager.ast))
-          .must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'), (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01')]
+      it "should import large set of data using ToSql" do
+        insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
+      	insert_manager.bulk_insert(@cols, @data)
+      	sql = compile(insert_manager.ast)
+    	  sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'), (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01')]
       end
-    end
+
+
+	end
   end
-end
+end