ajax-datatables-rails 0.4.3 → 1.0.0

data/lib/ajax-datatables-rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AjaxDatatablesRails
-  VERSION = '0.4.3'
+  VERSION = '1.0.0'
 end

data/lib/ajax_datatables_rails.rb

@@ -9,7 +9,8 @@ module AjaxDatatablesRails
   require 'ajax-datatables-rails/datatable/simple_order'
   require 'ajax-datatables-rails/datatable/column/search'
   require 'ajax-datatables-rails/datatable/column/order'
-  require 'ajax-datatables-rails/datatable/column/date_filter' unless AjaxDatatablesRails.old_rails?
+  require 'ajax-datatables-rails/datatable/column/date_filter'
   require 'ajax-datatables-rails/datatable/column'
   require 'ajax-datatables-rails/orm/active_record'
+  require 'ajax-datatables-rails/active_record'
 end

data/lib/generators/datatable/config_generator.rb

@@ -6,10 +6,10 @@ module Datatable
   module Generators
     class ConfigGenerator < ::Rails::Generators::Base
       source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
-      desc <<DESC
-Description:
-  Creates an initializer file for AjaxDatatablesRails configuration at config/initializers.
-DESC
+      desc <<~DESC
+        Description:
+          Creates an initializer file for AjaxDatatablesRails configuration at config/initializers.
+      DESC
 
       def copy_config_file
         template 'ajax_datatables_rails_config.rb', 'config/initializers/ajax_datatables_rails.rb'

data/lib/generators/datatable/templates/ajax_datatables_rails_config.rb

@@ -6,7 +6,4 @@ AjaxDatatablesRails.configure do |config|
 
   # Or you can use your rails environment adapter if you want a generic dev and production
   # config.db_adapter = Rails.configuration.database_configuration[Rails.env]['adapter'].to_sym
-
-  # available options for orm are: :active_record, :mongoid
-  # config.orm = :active_record
 end

data/lib/generators/rails/templates/datatable.rb

@@ -1,4 +1,4 @@
-class <%= datatable_name %> < AjaxDatatablesRails::Base
+class <%= datatable_name %> < AjaxDatatablesRails::ActiveRecord
 
   def view_columns
     # Declare strings in this format: ModelName.column_name

data/spec/ajax-datatables-rails/base_spec.rb

@@ -3,30 +3,26 @@ require 'spec_helper'
 describe AjaxDatatablesRails::Base do
 
   describe 'an instance' do
-    let(:view) { double('view', params: sample_params) }
-
-    it 'requires a view_context' do
+    it 'requires a hash of params' do
       expect { described_class.new }.to raise_error ArgumentError
     end
 
     it 'accepts an options hash' do
-      datatable = described_class.new(view, foo: 'bar')
+      datatable = described_class.new(sample_params, foo: 'bar')
       expect(datatable.options).to eq(foo: 'bar')
     end
   end
 
   context 'Public API' do
-    let(:view) { double('view', params: sample_params) }
-
     describe '#view_columns' do
       it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
+        datatable = described_class.new(sample_params)
         expect { datatable.view_columns }.to raise_error NotImplementedError
       end
 
       context 'child class implements view_columns' do
         it 'expects a hash based defining columns' do
-          datatable = ComplexDatatable.new(view)
+          datatable = ComplexDatatable.new(sample_params)
           expect(datatable.view_columns).to be_a(Hash)
         end
       end
@@ -34,19 +30,19 @@ describe AjaxDatatablesRails::Base do
 
     describe '#get_raw_records' do
       it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
+        datatable = described_class.new(sample_params)
         expect { datatable.get_raw_records }.to raise_error NotImplementedError
       end
     end
 
     describe '#data' do
       it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
+        datatable = described_class.new(sample_params)
         expect { datatable.data }.to raise_error NotImplementedError
       end
 
       context 'when data is defined as a hash' do
-        let(:datatable) { ComplexDatatable.new(view) }
+        let(:datatable) { ComplexDatatable.new(sample_params) }
 
         it 'should return an array of hashes' do
           create_list(:user, 5)
@@ -66,7 +62,7 @@ describe AjaxDatatablesRails::Base do
       end
 
       context 'when data is defined as a array' do
-        let(:datatable) { ComplexDatatableArray.new(view) }
+        let(:datatable) { ComplexDatatableArray.new(sample_params) }
 
         it 'should return an array of arrays' do
           create_list(:user, 5)
@@ -87,7 +83,7 @@ describe AjaxDatatablesRails::Base do
     end
 
     describe '#as_json' do
-      let(:datatable) { ComplexDatatable.new(view) }
+      let(:datatable) { ComplexDatatable.new(sample_params) }
 
       it 'should return a hash' do
         create_list(:user, 5)
@@ -111,73 +107,117 @@ describe AjaxDatatablesRails::Base do
         end
       end
     end
-  end
 
+    describe '#filter_records' do
+      let(:records) { User.all }
 
-  context 'Private API' do
-
-    let(:view) { double('view', params: sample_params) }
-    let(:datatable) { ComplexDatatable.new(view) }
+      let(:datatable) do
+        datatable = Class.new(ComplexDatatable) do
+          def filter_records(records)
+            raise NotImplementedError
+          end
+        end
+        datatable.new(sample_params)
+      end
 
-    before(:each) do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:orm) { nil }
+      it 'should allow method override' do
+        expect { datatable.filter_records(records) }.to raise_error(NotImplementedError)
+      end
     end
 
-    describe '#fetch_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:fetch_records) }.to raise_error NoMethodError
+    describe '#sort_records' do
+      let(:records) { User.all }
+
+      let(:datatable) do
+        datatable = Class.new(ComplexDatatable) do
+          def sort_records(records)
+            raise NotImplementedError
+          end
+        end
+        datatable.new(sample_params)
       end
-    end
 
-    describe '#filter_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:filter_records) }.to raise_error NoMethodError
+      it 'should allow method override' do
+        expect { datatable.sort_records(records) }.to raise_error(NotImplementedError)
       end
     end
 
-    describe '#sort_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:sort_records) }.to raise_error NoMethodError
+    describe '#paginate_records' do
+      let(:records) { User.all }
+
+      let(:datatable) do
+        datatable = Class.new(ComplexDatatable) do
+          def paginate_records(records)
+            raise NotImplementedError
+          end
+        end
+        datatable.new(sample_params)
+      end
+
+      it 'should allow method override' do
+        expect { datatable.paginate_records(records) }.to raise_error(NotImplementedError)
       end
     end
+  end
 
-    describe '#paginate_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:paginate_records) }.to raise_error NoMethodError
+
+  context 'Private API' do
+    context 'when orm is not implemented' do
+      let(:datatable) { AjaxDatatablesRails::Base.new(sample_params) }
+
+      describe '#fetch_records' do
+        it 'raises an error if it does not include an ORM module' do
+          expect { datatable.fetch_records }.to raise_error NoMethodError
+        end
+      end
+
+      describe '#filter_records' do
+        it 'raises an error if it does not include an ORM module' do
+          expect { datatable.filter_records }.to raise_error NoMethodError
+        end
+      end
+
+      describe '#sort_records' do
+        it 'raises an error if it does not include an ORM module' do
+          expect { datatable.sort_records }.to raise_error NoMethodError
+        end
+      end
+
+      describe '#paginate_records' do
+        it 'raises an error if it does not include an ORM module' do
+          expect { datatable.paginate_records }.to raise_error NoMethodError
+        end
       end
     end
 
     describe 'helper methods' do
       describe '#offset' do
         it 'defaults to 0' do
-          default_view = double('view', params: {})
-          datatable = described_class.new(default_view)
+          datatable = described_class.new({})
           expect(datatable.datatable.send(:offset)).to eq(0)
         end
 
         it 'matches the value on view params[:start]' do
-          paginated_view = double('view', params: { start: '11' })
-          datatable = described_class.new(paginated_view)
+          datatable = described_class.new({ start: '11' })
           expect(datatable.datatable.send(:offset)).to eq(11)
         end
       end
 
       describe '#page' do
         it 'calculates page number from params[:start] and #per_page' do
-          paginated_view = double('view', params: { start: '11' })
-          datatable = described_class.new(paginated_view)
+          datatable = described_class.new({ start: '11' })
           expect(datatable.datatable.send(:page)).to eq(2)
         end
       end
 
       describe '#per_page' do
         it 'defaults to 10' do
-          datatable = described_class.new(view)
+          datatable = described_class.new(sample_params)
           expect(datatable.datatable.send(:per_page)).to eq(10)
         end
 
         it 'matches the value on view params[:length]' do
-          other_view = double('view', params: { length: 20 })
+          other_view = { length: 20 }
           datatable = described_class.new(other_view)
           expect(datatable.datatable.send(:per_page)).to eq(20)
         end

data/spec/ajax-datatables-rails/configuration_spec.rb

@@ -20,10 +20,6 @@ describe AjaxDatatablesRails::Configuration do
   let(:config) { AjaxDatatablesRails::Configuration.new }
 
   describe 'default config' do
-    it 'default orm should :active_record' do
-      expect(config.orm).to eq(:active_record)
-    end
-
     it 'default db_adapter should :postgresql' do
       expect(config.db_adapter).to eq(:postgresql)
     end
@@ -34,10 +30,5 @@ describe AjaxDatatablesRails::Configuration do
       config.db_adapter = :mysql
       expect(config.db_adapter).to eq(:mysql)
     end
-
-    it 'accepts a custom orm value' do
-      config.orm = :mongoid
-      expect(config.orm).to eq(:mongoid)
-    end
   end
 end

data/spec/ajax-datatables-rails/datatable/column_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Datatable::Column do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view) }
+  let(:datatable) { ComplexDatatable.new(sample_params) }
 
   describe 'username column' do
 
@@ -121,34 +120,81 @@ describe AjaxDatatablesRails::Datatable::Column do
       end
     end
 
-    unless AjaxDatatablesRails.old_rails?
-      describe '#delimiter' do
-        it 'should be - by default' do
-          expect(column.delimiter).to eq('-')
-        end
+    describe '#delimiter' do
+      it 'should be - by default' do
+        expect(column.delimiter).to eq('-')
       end
     end
   end
 
-  describe '#formater' do
-    let(:datatable) { DatatableWithFormater.new(view) }
+  describe '#formatter' do
+    let(:datatable) { DatatableWithFormater.new(sample_params) }
     let(:column) { datatable.datatable.columns.find { |c| c.data == 'last_name' } }
 
     it 'should be a proc' do
-      expect(column.formater).to be_a(Proc)
+      expect(column.formatter).to be_a(Proc)
     end
   end
 
   describe '#filter' do
-    let(:datatable) { DatatableCondProc.new(view) }
+    let(:datatable) { DatatableCondProc.new(sample_params) }
     let(:column) { datatable.datatable.columns.find { |c| c.data == 'username' } }
 
     it 'should be a proc' do
       config = column.instance_variable_get('@view_column')
       filter = config[:cond]
       expect(filter).to be_a(Proc)
-      expect(filter).to receive(:call).with(column, column.formated_value)
+      expect(filter).to receive(:call).with(column, column.formatted_value)
       column.filter
     end
   end
+
+  describe '#type_cast' do
+    let(:column) { datatable.datatable.columns.first }
+
+    it 'returns VARCHAR if :db_adapter is :pg' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :pg }
+      expect(column.send(:type_cast)).to eq('VARCHAR')
+    end
+
+    it 'returns VARCHAR if :db_adapter is :postgre' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgre }
+      expect(column.send(:type_cast)).to eq('VARCHAR')
+    end
+
+    it 'returns VARCHAR if :db_adapter is :postgresql' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgresql }
+      expect(column.send(:type_cast)).to eq('VARCHAR')
+    end
+
+    it 'returns VARCHAR if :db_adapter is :oracle' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracle }
+      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
+    end
+
+    it 'returns VARCHAR if :db_adapter is :oracleenhanced' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracleenhanced }
+      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
+    end
+
+    it 'returns CHAR if :db_adapter is :mysql2' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql2 }
+      expect(column.send(:type_cast)).to eq('CHAR')
+    end
+
+    it 'returns CHAR if :db_adapter is :mysql' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql }
+      expect(column.send(:type_cast)).to eq('CHAR')
+    end
+
+    it 'returns TEXT if :db_adapter is :sqlite' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite }
+      expect(column.send(:type_cast)).to eq('TEXT')
+    end
+
+    it 'returns TEXT if :db_adapter is :sqlite3' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite3 }
+      expect(column.send(:type_cast)).to eq('TEXT')
+    end
+  end
 end

data/spec/ajax-datatables-rails/datatable/datatable_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Datatable::Datatable do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view).datatable }
+  let(:datatable) { ComplexDatatable.new(sample_params).datatable }
   let(:order_option) { {'0'=>{'column'=>'0', 'dir'=>'asc'}, '1'=>{'column'=>'1', 'dir'=>'desc'}} }
 
   describe 'order methods' do

data/spec/ajax-datatables-rails/datatable/simple_order_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Datatable::SimpleOrder do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view).datatable }
+  let(:datatable) { ComplexDatatable.new(sample_params).datatable }
   let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'column' => '1', 'dir' => 'desc'}) }
   let(:simple_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(datatable, options) }
 
@@ -26,7 +25,7 @@ describe AjaxDatatablesRails::Datatable::SimpleOrder do
     end
 
     describe 'using column option' do
-      let(:sorted_datatable) { DatatableOrderNullsLast.new(view).datatable }
+      let(:sorted_datatable) { DatatableOrderNullsLast.new(sample_params).datatable }
       let(:nulls_last_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(sorted_datatable, options) }
 
       it 'sql query' do

data/spec/ajax-datatables-rails/extended_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Base do
   describe 'it can transform search value before asking the database' do
-    let(:view) { double('view', params: sample_params) }
-    let(:datatable) { DatatableWithFormater.new(view) }
+    let(:datatable) { DatatableWithFormater.new(sample_params) }
 
     before(:each) do
       create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'DOE')

data/spec/ajax-datatables-rails/orm/active_record_filter_records_spec.rb

@@ -2,25 +2,24 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::ORM::ActiveRecord do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view) }
+  let(:datatable) { ComplexDatatable.new(sample_params) }
   let(:records) { User.all }
 
   describe '#filter_records' do
     it 'requires a records collection as argument' do
-      expect { datatable.send(:filter_records) }.to raise_error(ArgumentError)
+      expect { datatable.filter_records() }.to raise_error(ArgumentError)
     end
 
     it 'performs a simple search first' do
       datatable.params[:search] = { value: 'msmith' }
       expect(datatable).to receive(:build_conditions_for_datatable)
-      datatable.send(:filter_records, records)
+      datatable.filter_records(records)
     end
 
     it 'performs a composite search second' do
       datatable.params[:search] = { value: '' }
       expect(datatable).to receive(:build_conditions_for_selected_columns)
-      datatable.send(:filter_records, records)
+      datatable.filter_records(records)
     end
   end
 
@@ -32,14 +31,14 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
 
     it 'returns an Arel object' do
       datatable.params[:search] = { value: 'msmith' }
-      result = datatable.send(:build_conditions_for_datatable)
+      result = datatable.build_conditions_for_datatable
       expect(result).to be_a(Arel::Nodes::Grouping)
     end
 
     context 'no search query' do
       it 'returns empty query' do
         datatable.params[:search] = { value: '' }
-        expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+        expect(datatable.build_conditions_for_datatable).to be_blank
       end
     end
 
@@ -54,11 +53,11 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
         end
 
         it 'returns empty query result' do
-          expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+          expect(datatable.build_conditions_for_datatable).to be_blank
         end
 
         it 'returns filtered results' do
-          query = datatable.send(:build_conditions_for_datatable)
+          query = datatable.build_conditions_for_datatable
           results = records.where(query).map(&:username)
           expect(results).to eq ['johndoe', 'msmith']
         end
@@ -70,11 +69,11 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
         end
 
         it 'returns empty query result' do
-          expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+          expect(datatable.build_conditions_for_datatable).to be_blank
         end
 
         it 'returns filtered results' do
-          query = datatable.send(:build_conditions_for_datatable)
+          query = datatable.build_conditions_for_datatable
           results = records.where(query).map(&:username)
           expect(results).to eq ['johndoe', 'msmith']
         end
@@ -88,7 +87,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
         end
 
         it 'returns a filtering query' do
-          query = datatable.send(:build_conditions_for_datatable)
+          query = datatable.build_conditions_for_datatable
           results = records.where(query).map(&:username)
           expect(results).to include('johndoe')
           expect(results).not_to include('msmith')
@@ -101,7 +100,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
         end
 
         it 'returns a filtering query' do
-          query = datatable.send(:build_conditions_for_datatable)
+          query = datatable.build_conditions_for_datatable
           results = records.where(query).map(&:username)
           expect(results).to eq ['johndoe']
           expect(results).not_to include('msmith')
@@ -123,14 +122,14 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
       end
 
       it 'returns an Arel object' do
-        result = datatable.send(:build_conditions_for_selected_columns)
+        result = datatable.build_conditions_for_selected_columns
         expect(result).to be_a(Arel::Nodes::And)
       end
 
       if AjaxDatatablesRails.config.db_adapter == :postgresql
         context 'when db_adapter is postgresql' do
           it 'can call #to_sql on returned object' do
-            result = datatable.send(:build_conditions_for_selected_columns)
+            result = datatable.build_conditions_for_selected_columns
             expect(result).to respond_to(:to_sql)
             expect(result.to_sql).to eq(
               "CAST(\"users\".\"username\" AS VARCHAR) ILIKE '%doe%' AND CAST(\"users\".\"email\" AS VARCHAR) ILIKE '%example%'"
@@ -142,7 +141,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
       if AjaxDatatablesRails.config.db_adapter.in? %i[oracle oracleenhanced]
         context 'when db_adapter is oracle' do
           it 'can call #to_sql on returned object' do
-            result = datatable.send(:build_conditions_for_selected_columns)
+            result = datatable.build_conditions_for_selected_columns
             expect(result).to respond_to(:to_sql)
             expect(result.to_sql).to eq(
               "CAST(\"USERS\".\"USERNAME\" AS VARCHAR2(4000)) LIKE '%doe%' AND CAST(\"USERS\".\"EMAIL\" AS VARCHAR2(4000)) LIKE '%example%'"
@@ -154,7 +153,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
       if AjaxDatatablesRails.config.db_adapter.in? %i[mysql2 sqlite3]
         context 'when db_adapter is mysql2' do
           it 'can call #to_sql on returned object' do
-            result = datatable.send(:build_conditions_for_selected_columns)
+            result = datatable.build_conditions_for_selected_columns
             expect(result).to respond_to(:to_sql)
             expect(result.to_sql).to eq(
               "CAST(`users`.`username` AS CHAR) LIKE '%doe%' AND CAST(`users`.`email` AS CHAR) LIKE '%example%'"
@@ -166,7 +165,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
 
     it 'calls #build_conditions_for_selected_columns' do
       expect(datatable).to receive(:build_conditions_for_selected_columns)
-      datatable.send(:build_conditions)
+      datatable.build_conditions
     end
 
     context 'with search values in columns' do
@@ -175,7 +174,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
       end
 
       it 'returns a filtered set of records' do
-        query = datatable.send(:build_conditions_for_selected_columns)
+        query = datatable.build_conditions_for_selected_columns
         results = records.where(query).map(&:username)
         expect(results).to include('johndoe')
         expect(results).not_to include('msmith')
@@ -183,142 +182,90 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
   end
 
-  describe '#type_cast helper method' do
-    let(:view) { double('view', params: sample_params) }
-    let(:column) { ComplexDatatable.new(view).datatable.columns.first }
-
-    it 'returns VARCHAR if :db_adapter is :pg' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :pg }
-      expect(column.send(:type_cast)).to eq('VARCHAR')
-    end
-
-    it 'returns VARCHAR if :db_adapter is :postgre' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgre }
-      expect(column.send(:type_cast)).to eq('VARCHAR')
-    end
-
-    it 'returns VARCHAR if :db_adapter is :postgresql' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgresql }
-      expect(column.send(:type_cast)).to eq('VARCHAR')
-    end
-
-    it 'returns VARCHAR if :db_adapter is :oracle' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracle }
-      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
-    end
-
-    it 'returns VARCHAR if :db_adapter is :oracleenhanced' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracleenhanced }
-      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
-    end
-
-    it 'returns CHAR if :db_adapter is :mysql2' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql2 }
-      expect(column.send(:type_cast)).to eq('CHAR')
-    end
+  describe 'filter conditions' do
+    describe 'it can filter records with condition :date_range' do
+      let(:datatable) { DatatableCondDate.new(sample_params) }
 
-    it 'returns CHAR if :db_adapter is :mysql' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql }
-      expect(column.send(:type_cast)).to eq('CHAR')
-    end
+      before(:each) do
+        create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'Doe', created_at: '01/01/2000')
+        create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'Smith', created_at: '01/02/2000')
+      end
 
-    it 'returns TEXT if :db_adapter is :sqlite' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite }
-      expect(column.send(:type_cast)).to eq('TEXT')
-    end
+      context 'when range is empty' do
+        it 'should not filter records' do
+          datatable.params[:columns]['5'][:search][:value] = '-'
+          expect(datatable.data.size).to eq 2
+          item = datatable.data.first
+          expect(item[:last_name]).to eq 'Doe'
+        end
+      end
 
-    it 'returns TEXT if :db_adapter is :sqlite3' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite3 }
-      expect(column.send(:type_cast)).to eq('TEXT')
-    end
-  end
+      context 'when start date is filled' do
+        it 'should filter records created after this date' do
+          datatable.params[:columns]['5'][:search][:value] = '31/12/1999-'
+          expect(datatable.data.size).to eq 2
+        end
+      end
 
-  describe 'filter conditions' do
-    unless AjaxDatatablesRails.old_rails?
-      describe 'it can filter records with condition :date_range' do
-        let(:datatable) { DatatableCondDate.new(view) }
+      context 'when end date is filled' do
+        it 'should filter records created before this date' do
+          datatable.params[:columns]['5'][:search][:value] = '-31/12/1999'
+          expect(datatable.data.size).to eq 0
+        end
+      end
 
-        before(:each) do
-          create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'Doe', created_at: '01/01/2000')
-          create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'Smith', created_at: '01/02/2000')
+      context 'when both date are filled' do
+        it 'should filter records created between the range' do
+          datatable.params[:columns]['5'][:search][:value] = '01/12/1999-15/01/2000'
+          expect(datatable.data.size).to eq 1
         end
+      end
 
+      context 'when another filter is active' do
         context 'when range is empty' do
-          it 'should not filter records' do
+          it 'should filter records' do
+            datatable.params[:columns]['0'][:search][:value] = 'doe'
             datatable.params[:columns]['5'][:search][:value] = '-'
-            expect(datatable.data.size).to eq 2
+            expect(datatable.data.size).to eq 1
             item = datatable.data.first
             expect(item[:last_name]).to eq 'Doe'
           end
         end
 
         context 'when start date is filled' do
-          it 'should filter records created after this date' do
-            datatable.params[:columns]['5'][:search][:value] = '31/12/1999-'
-            expect(datatable.data.size).to eq 2
+          it 'should filter records' do
+            datatable.params[:columns]['0'][:search][:value] = 'doe'
+            datatable.params[:columns]['5'][:search][:value] = '01/12/1999-'
+            expect(datatable.data.size).to eq 1
+            item = datatable.data.first
+            expect(item[:last_name]).to eq 'Doe'
           end
         end
 
         context 'when end date is filled' do
-          it 'should filter records created before this date' do
-            datatable.params[:columns]['5'][:search][:value] = '-31/12/1999'
-            expect(datatable.data.size).to eq 0
+          it 'should filter records' do
+            datatable.params[:columns]['0'][:search][:value] = 'doe'
+            datatable.params[:columns]['5'][:search][:value] = '-15/01/2000'
+            expect(datatable.data.size).to eq 1
+            item = datatable.data.first
+            expect(item[:last_name]).to eq 'Doe'
           end
         end
 
         context 'when both date are filled' do
-          it 'should filter records created between the range' do
+          it 'should filter records' do
+            datatable.params[:columns]['0'][:search][:value] = 'doe'
             datatable.params[:columns]['5'][:search][:value] = '01/12/1999-15/01/2000'
             expect(datatable.data.size).to eq 1
-          end
-        end
-
-        context 'when another filter is active' do
-          context 'when range is empty' do
-            it 'should filter records' do
-              datatable.params[:columns]['0'][:search][:value] = 'doe'
-              datatable.params[:columns]['5'][:search][:value] = '-'
-              expect(datatable.data.size).to eq 1
-              item = datatable.data.first
-              expect(item[:last_name]).to eq 'Doe'
-            end
-          end
-
-          context 'when start date is filled' do
-            it 'should filter records' do
-              datatable.params[:columns]['0'][:search][:value] = 'doe'
-              datatable.params[:columns]['5'][:search][:value] = '01/12/1999-'
-              expect(datatable.data.size).to eq 1
-              item = datatable.data.first
-              expect(item[:last_name]).to eq 'Doe'
-            end
-          end
-
-          context 'when end date is filled' do
-            it 'should filter records' do
-              datatable.params[:columns]['0'][:search][:value] = 'doe'
-              datatable.params[:columns]['5'][:search][:value] = '-15/01/2000'
-              expect(datatable.data.size).to eq 1
-              item = datatable.data.first
-              expect(item[:last_name]).to eq 'Doe'
-            end
-          end
-
-          context 'when both date are filled' do
-            it 'should filter records' do
-              datatable.params[:columns]['0'][:search][:value] = 'doe'
-              datatable.params[:columns]['5'][:search][:value] = '01/12/1999-15/01/2000'
-              expect(datatable.data.size).to eq 1
-              item = datatable.data.first
-              expect(item[:last_name]).to eq 'Doe'
-            end
+            item = datatable.data.first
+            expect(item[:last_name]).to eq 'Doe'
           end
         end
       end
     end
 
     describe 'it can filter records with condition :start_with' do
-      let(:datatable) { DatatableCondStartWith.new(view) }
+      let(:datatable) { DatatableCondStartWith.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'John')
@@ -334,7 +281,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :end_with' do
-      let(:datatable) { DatatableCondEndWith.new(view) }
+      let(:datatable) { DatatableCondEndWith.new(sample_params) }
 
       before(:each) do
         create(:user, last_name: 'JOHN')
@@ -361,7 +308,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :like' do
-      let(:datatable) { DatatableCondLike.new(view) }
+      let(:datatable) { DatatableCondLike.new(sample_params) }
 
       before(:each) do
         create(:user, email: 'john@foo.com')
@@ -377,7 +324,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :string_eq' do
-      let(:datatable) { DatatableCondStringEq.new(view) }
+      let(:datatable) { DatatableCondStringEq.new(sample_params) }
 
       before(:each) do
         create(:user, email: 'john@foo.com')
@@ -393,7 +340,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :null_value' do
-      let(:datatable) { DatatableCondNullValue.new(view) }
+      let(:datatable) { DatatableCondNullValue.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', email: 'foo@bar.com')
@@ -420,7 +367,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :eq' do
-      let(:datatable) { DatatableCondEq.new(view) }
+      let(:datatable) { DatatableCondEq.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -436,7 +383,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :not_eq' do
-      let(:datatable) { DatatableCondNotEq.new(view) }
+      let(:datatable) { DatatableCondNotEq.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -452,7 +399,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :lt' do
-      let(:datatable) { DatatableCondLt.new(view) }
+      let(:datatable) { DatatableCondLt.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -468,7 +415,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :gt' do
-      let(:datatable) { DatatableCondGt.new(view) }
+      let(:datatable) { DatatableCondGt.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -484,7 +431,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :lteq' do
-      let(:datatable) { DatatableCondLteq.new(view) }
+      let(:datatable) { DatatableCondLteq.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -498,7 +445,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :gteq' do
-      let(:datatable) { DatatableCondGteq.new(view) }
+      let(:datatable) { DatatableCondGteq.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -512,7 +459,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :in' do
-      let(:datatable) { DatatableCondIn.new(view) }
+      let(:datatable) { DatatableCondIn.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -528,7 +475,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :in with regex' do
-      let(:datatable) { DatatableCondInWithRegex.new(view) }
+      let(:datatable) { DatatableCondInWithRegex.new(sample_params) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -545,7 +492,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'Integer overflows' do
-      let(:datatable) { DatatableCondEq.new(view) }
+      let(:datatable) { DatatableCondEq.new(sample_params) }
       let(:largest_postgresql_integer_value) { 2147483647 }
       let(:smallest_postgresql_integer_value) { -2147483648 }