ajax-datatables-rails 0.4.2 → 1.3.0

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,106 @@ 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
+      expect(datatable).to receive(:db_adapter) { :pg }
+      expect(column.send(:type_cast)).to eq('VARCHAR')
+    end
+
+    it 'returns VARCHAR if :db_adapter is :postgre' do
+      expect(datatable).to receive(:db_adapter) { :postgre }
+      expect(column.send(:type_cast)).to eq('VARCHAR')
+    end
+
+    it 'returns VARCHAR if :db_adapter is :postgresql' do
+      expect(datatable).to receive(:db_adapter) { :postgresql }
+      expect(column.send(:type_cast)).to eq('VARCHAR')
+    end
+
+    it 'returns VARCHAR2(4000) if :db_adapter is :oracle' do
+      expect(datatable).to receive(:db_adapter) { :oracle }
+      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
+    end
+
+    it 'returns VARCHAR2(4000) if :db_adapter is :oracleenhanced' do
+      expect(datatable).to receive(:db_adapter) { :oracleenhanced }
+      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
+    end
+
+    it 'returns CHAR if :db_adapter is :mysql2' do
+      expect(datatable).to receive(:db_adapter) { :mysql2 }
+      expect(column.send(:type_cast)).to eq('CHAR')
+    end
+
+    it 'returns CHAR if :db_adapter is :mysql' do
+      expect(datatable).to receive(:db_adapter) { :mysql }
+      expect(column.send(:type_cast)).to eq('CHAR')
+    end
+
+    it 'returns TEXT if :db_adapter is :sqlite' do
+      expect(datatable).to receive(:db_adapter) { :sqlite }
+      expect(column.send(:type_cast)).to eq('TEXT')
+    end
+
+    it 'returns TEXT if :db_adapter is :sqlite3' do
+      expect(datatable).to receive(:db_adapter) { :sqlite3 }
+      expect(column.send(:type_cast)).to eq('TEXT')
+    end
+
+    it 'returns VARCHAR(4000) if :db_adapter is :sqlserver' do
+      expect(datatable).to receive(:db_adapter) { :sqlserver }
+      expect(column.send(:type_cast)).to eq('VARCHAR(4000)')
+    end
+  end
+
+  describe 'when empty column' do
+    before do
+      datatable.params[:columns] = {'0'=>{'data'=>'', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'searchvalue', 'regex'=>'false'}}}
+    end
+
+    it 'raises error' do
+      expect { datatable.to_json }.to raise_error(AjaxDatatablesRails::Error::InvalidSearchColumn).with_message("Unknown column. Check that `data` field is filled on JS side with the column name")
+    end
+  end
+
+  describe 'when unknown column' do
+    before do
+      datatable.params[:columns] = {'0'=>{'data'=>'foo', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'searchvalue', 'regex'=>'false'}}}
+    end
+
+    it 'raises error' do
+      expect { datatable.to_json }.to raise_error(AjaxDatatablesRails::Error::InvalidSearchColumn).with_message("Check that column 'foo' exists in view_columns")
+    end
+  end
 end

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

@@ -2,11 +2,12 @@ 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(:datatable_json) { ComplexDatatable.new(sample_params_json).datatable }
   let(:order_option) { {'0'=>{'column'=>'0', 'dir'=>'asc'}, '1'=>{'column'=>'1', 'dir'=>'desc'}} }
+  let(:order_option_json) { [{'column'=>'0', 'dir'=>'asc'}, {'column'=>'1', 'dir'=>'desc'}] }
 
-  describe 'order methods' do
+  shared_examples 'order methods' do
     it 'should be orderable' do
       expect(datatable.orderable?).to eq(true)
     end
@@ -36,6 +37,28 @@ describe AjaxDatatablesRails::Datatable::Datatable do
     end
   end
 
+  shared_examples 'columns methods' do
+    it 'should have 4 columns' do
+      expect(datatable.columns.count).to eq(6)
+    end
+
+    it 'child class' do
+      expect(datatable.columns.first).to be_a(AjaxDatatablesRails::Datatable::Column)
+    end
+  end
+
+  describe 'with query params' do
+    it_behaves_like 'order methods'
+    it_behaves_like 'columns methods'
+  end
+
+  describe 'with json params' do
+    let(:order_option) { order_option_json }
+    let(:datatable) { datatable_json }
+    it_behaves_like 'order methods'
+    it_behaves_like 'columns methods'
+  end
+
   describe 'search methods' do
     it 'should be searchable' do
       datatable.options[:search][:value] = 'atom'
@@ -52,36 +75,51 @@ describe AjaxDatatablesRails::Datatable::Datatable do
     end
   end
 
-  describe 'columns methods' do
-    it 'should have 4 columns' do
-      expect(datatable.columns.count).to eq(6)
+  describe 'option methods' do
+    describe '#paginate?' do
+      it {
+        expect(datatable.paginate?).to be(true)
+      }
     end
 
-    it 'child class' do
-      expect(datatable.columns.first).to be_a(AjaxDatatablesRails::Datatable::Column)
-    end
-  end
+    describe '#per_page' do
+      context 'when params[:length] is missing' do
+        it 'defaults to 10' do
+          expect(datatable.per_page).to eq(10)
+        end
+      end
 
-  describe 'option methods' do
-    before :each do
-      datatable.options[:start] = '50'
-      datatable.options[:length] = '15'
-    end
+      context 'when params[:length] is passed' do
+        let(:datatable) { ComplexDatatable.new({ length: '20' }).datatable }
 
-    it 'paginate?' do
-      expect(datatable.paginate?).to be(true)
+        it 'matches the value on view params[:length]' do
+          expect(datatable.per_page).to eq(20)
+        end
+      end
     end
 
-    it 'offset' do
-      expect(datatable.offset).to eq(50)
-    end
+    describe '#offset' do
+      context 'when params[:start] is missing' do
+        it 'defaults to 0' do
+          expect(datatable.offset).to eq(0)
+        end
+      end
+
+      context 'when params[:start] is passed' do
+        let(:datatable) { ComplexDatatable.new({ start: '11' }).datatable }
 
-    it 'page' do
-      expect(datatable.page).to eq(4)
+        it 'matches the value on view params[:start]' do
+          expect(datatable.offset).to eq(11)
+        end
+      end
     end
 
-    it 'per_page' do
-      expect(datatable.per_page).to eq(15)
+    describe '#page' do
+      let(:datatable) { ComplexDatatable.new({ start: '11' }).datatable }
+
+      it 'calculates page number from params[:start] and #per_page' do
+        expect(datatable.page).to eq(2)
+      end
     end
   end
 end

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

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Datatable::SimpleOrder do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view).datatable }
+  let(:parent) { ComplexDatatable.new(sample_params) }
+  let(:datatable) { parent.datatable }
   let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'column' => '1', 'dir' => 'desc'}) }
   let(:simple_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(datatable, options) }
 
@@ -14,27 +14,47 @@ describe AjaxDatatablesRails::Datatable::SimpleOrder do
   end
 
   describe 'option methods with nulls last' do
-    describe 'using global option' do
-      before { AjaxDatatablesRails.config.nulls_last = true }
-      after  { AjaxDatatablesRails.config.nulls_last = false }
+    describe 'using class option' do
+      before { parent.nulls_last = true }
+      after  { parent.nulls_last = false }
 
       it 'sql query' do
+        skip('unsupported database adapter') if ENV['DB_ADAPTER'] == 'oracle_enhanced'
+
         expect(simple_order.query('email')).to eq(
-          'CASE WHEN email IS NULL THEN 1 ELSE 0 END, email DESC'
+          "email DESC #{nulls_last_sql(parent)}"
         )
       end
     end
 
     describe 'using column option' do
-      let(:sorted_datatable) { DatatableOrderNullsLast.new(view).datatable }
+      let(:parent) { DatatableOrderNullsLast.new(sample_params) }
+      let(:sorted_datatable) { parent.datatable }
       let(:nulls_last_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(sorted_datatable, options) }
 
-      it 'sql query' do
-        expect(nulls_last_order.query('email')).to eq(
-          'CASE WHEN email IS NULL THEN 1 ELSE 0 END, email DESC'
-        )
+      context 'with postgres database adapter' do
+        before { parent.db_adapter = :pg }
+
+        it 'sql query' do
+          expect(nulls_last_order.query('email')).to eq('email DESC NULLS LAST')
+        end
+      end
+
+      context 'with sqlite database adapter' do
+        before { parent.db_adapter = :sqlite }
+
+        it 'sql query' do
+          expect(nulls_last_order.query('email')).to eq('email DESC IS NULL')
+        end
+      end
+
+      context 'with mysql database adapter' do
+        before { parent.db_adapter = :mysql }
+
+        it 'sql query' do
+          expect(nulls_last_order.query('email')).to eq('email DESC IS NULL')
+        end
       end
     end
   end
-
 end

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

@@ -2,25 +2,47 @@ 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
+
+  describe '#build_conditions' do
+    before(:each) do
+      create(:user, username: 'johndoe', email: 'johndoe@example.com')
+      create(:user, username: 'msmith',  email: 'mary.smith@example.com')
+      create(:user, username: 'hsmith',  email: 'henry.smith@example.net')
+    end
+
+    context 'with column and global search' do
+      before(:each) do
+        datatable.params[:search] = { value: 'example.com', regex: 'false' }
+        datatable.params[:columns]['0'][:search][:value] = 'smith'
+      end
+
+      it 'return a filtered set of records' do
+        query = datatable.build_conditions
+        results = records.where(query).map(&:username)
+        expect(results).to include('msmith')
+        expect(results).not_to include('johndoe')
+        expect(results).not_to include('hsmith')
+      end
     end
   end
 
@@ -32,14 +54,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 +76,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 +92,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 +110,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,12 +123,29 @@ 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')
         end
       end
+
+      # TODO: improve (or delete?) this test
+      context 'when column.search_query returns nil' do
+        let(:datatable) { DatatableCondUnknown.new(sample_params) }
+
+        before(:each) do
+          datatable.params[:search] = { value: 'john doe', regex: 'false' }
+        end
+
+        it 'does not raise error' do
+          allow_any_instance_of(AjaxDatatablesRails::Datatable::Column).to receive(:valid_search_condition?).and_return(true)
+
+          expect {
+            datatable.data.size
+          }.to_not raise_error
+        end
+      end
     end
   end
 
@@ -123,14 +162,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
+      if ENV['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%'"
@@ -139,10 +178,10 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
         end
       end
 
-      if AjaxDatatablesRails.config.db_adapter.in? %i[oracle oracleenhanced]
+      if ENV['DB_ADAPTER'] == 'oracle_enhanced'
         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%'"
@@ -151,10 +190,10 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
         end
       end
 
-      if AjaxDatatablesRails.config.db_adapter.in? %i[mysql2 sqlite3]
+      if ENV['DB_ADAPTER'] == 'mysql2'
         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 +205,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 +214,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,60 +222,10 @@ 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
-
-    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
-
   describe 'filter conditions' do
-    unless AjaxDatatablesRails.old_rails?
+    context 'date condition' do
       describe 'it can filter records with condition :date_range' do
-        let(:datatable) { DatatableCondDate.new(view) }
+        let(:datatable) { DatatableCondDate.new(sample_params) }
 
         before(:each) do
           create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'Doe', created_at: '01/01/2000')
@@ -317,226 +306,345 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
       end
     end
 
-    describe 'it can filter records with condition :start_with' do
-      let(:datatable) { DatatableCondStartWith.new(view) }
+    context 'numeric condition' do
+      describe 'it can filter records with condition :eq' do
+        let(:datatable) { DatatableCondEq.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'John')
-        create(:user, first_name: 'Mary')
-      end
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['2'][:search][:value] = 'Jo'
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'John'
+        it 'should filter records matching' do
+          datatable.params[:columns]['4'][:search][:value] = 1
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:first_name]).to eq 'john'
+        end
       end
-    end
 
-    describe 'it can filter records with condition :end_with' do
-      let(:datatable) { DatatableCondEndWith.new(view) }
+      describe 'it can filter records with condition :not_eq' do
+        let(:datatable) { DatatableCondNotEq.new(sample_params) }
 
-      before(:each) do
-        create(:user, last_name: 'JOHN')
-        create(:user, last_name: 'MARY')
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
+
+        it 'should filter records matching' do
+          datatable.params[:columns]['4'][:search][:value] = 1
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:first_name]).to eq 'mary'
+        end
       end
 
-      if AjaxDatatablesRails.config.db_adapter == :oracleenhanced
-        context 'when db_adapter is oracleenhanced' do
-          it 'should filter records matching' do
-            datatable.params[:columns]['3'][:search][:value] = 'RY'
-            expect(datatable.data.size).to eq 1
-            item = datatable.data.first
-            expect(item[:last_name]).to eq 'MARY'
-          end
+      describe 'it can filter records with condition :lt' do
+        let(:datatable) { DatatableCondLt.new(sample_params) }
+
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
         end
-      else
+
         it 'should filter records matching' do
-          datatable.params[:columns]['3'][:search][:value] = 'ry'
+          datatable.params[:columns]['4'][:search][:value] = 2
           expect(datatable.data.size).to eq 1
           item = datatable.data.first
-          expect(item[:last_name]).to eq 'MARY'
+          expect(item[:first_name]).to eq 'john'
         end
       end
-    end
 
-    describe 'it can filter records with condition :null_value' do
-      let(:datatable) { DatatableCondNullValue.new(view) }
+      describe 'it can filter records with condition :gt' do
+        let(:datatable) { DatatableCondGt.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', email: 'foo@bar.com')
-        create(:user, first_name: 'mary', email: nil)
-      end
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
 
-      context 'when condition is NULL' do
         it 'should filter records matching' do
-          datatable.params[:columns]['1'][:search][:value] = 'NULL'
+          datatable.params[:columns]['4'][:search][:value] = 1
           expect(datatable.data.size).to eq 1
           item = datatable.data.first
           expect(item[:first_name]).to eq 'mary'
         end
       end
 
-      context 'when condition is !NULL' do
+      describe 'it can filter records with condition :lteq' do
+        let(:datatable) { DatatableCondLteq.new(sample_params) }
+
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
+
+        it 'should filter records matching' do
+          datatable.params[:columns]['4'][:search][:value] = 2
+          expect(datatable.data.size).to eq 2
+        end
+      end
+
+      describe 'it can filter records with condition :gteq' do
+        let(:datatable) { DatatableCondGteq.new(sample_params) }
+
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
+
         it 'should filter records matching' do
-          datatable.params[:columns]['1'][:search][:value] = '!NULL'
+          datatable.params[:columns]['4'][:search][:value] = 1
+          expect(datatable.data.size).to eq 2
+        end
+      end
+
+      describe 'it can filter records with condition :in' do
+        let(:datatable) { DatatableCondIn.new(sample_params) }
+
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
+
+        it 'should filter records matching' do
+          datatable.params[:columns]['4'][:search][:value] = [1]
           expect(datatable.data.size).to eq 1
           item = datatable.data.first
           expect(item[:first_name]).to eq 'john'
         end
       end
-    end
 
-    describe 'it can filter records with condition :eq' do
-      let(:datatable) { DatatableCondEq.new(view) }
+      describe 'it can filter records with condition :in with regex' do
+        let(:datatable) { DatatableCondInWithRegex.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = 1
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'john'
+        it 'should filter records matching' do
+          datatable.params[:columns]['4'][:search][:value] = '1|2'
+          datatable.params[:order]['0'] = { column: '4', dir: 'asc' }
+          expect(datatable.data.size).to eq 2
+          item = datatable.data.first
+          expect(item[:first_name]).to eq 'john'
+        end
       end
-    end
 
-    describe 'it can filter records with condition :not_eq' do
-      let(:datatable) { DatatableCondNotEq.new(view) }
+      describe 'Integer overflows' do
+        let(:datatable) { DatatableCondEq.new(sample_params) }
+        let(:largest_postgresql_integer_value) { 2147483647 }
+        let(:smallest_postgresql_integer_value) { -2147483648 }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, first_name: 'john', post_id: 1)
+          create(:user, first_name: 'mary', post_id: 2)
+          create(:user, first_name: 'phil', post_id: largest_postgresql_integer_value)
+        end
+
+        it 'Returns an empty result if input value is too large' do
+          datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value + 1
+          expect(datatable.data.size).to eq 0
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = 1
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'mary'
+        it 'Returns an empty result if input value is too small' do
+          datatable.params[:columns]['4'][:search][:value] = smallest_postgresql_integer_value - 1
+          expect(datatable.data.size).to eq 0
+        end
+
+        it 'returns the matching user' do
+          datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value
+          expect(datatable.data.size).to eq 1
+        end
       end
     end
 
-    describe 'it can filter records with condition :lt' do
-      let(:datatable) { DatatableCondLt.new(view) }
+    context 'proc condition' do
+      describe 'it can filter records with lambda/proc condition' do
+        let(:datatable) { DatatableCondProc.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, username: 'johndoe', email: 'johndoe@example.com')
+          create(:user, username: 'johndie', email: 'johndie@example.com')
+          create(:user, username: 'msmith',  email: 'mary.smith@example.com')
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = 2
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'john'
+        it 'should filter records matching' do
+          datatable.params[:columns]['0'][:search][:value] = 'john'
+          expect(datatable.data.size).to eq 2
+          item = datatable.data.first
+          expect(item[:username]).to eq 'johndie'
+        end
       end
     end
 
-    describe 'it can filter records with condition :gt' do
-      let(:datatable) { DatatableCondGt.new(view) }
+    context 'string condition' do
+      describe 'it can filter records with condition :start_with' do
+        let(:datatable) { DatatableCondStartWith.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, first_name: 'John')
+          create(:user, first_name: 'Mary')
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = 1
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'mary'
+        it 'should filter records matching' do
+          datatable.params[:columns]['2'][:search][:value] = 'Jo'
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:first_name]).to eq 'John'
+        end
       end
-    end
 
-    describe 'it can filter records with condition :lteq' do
-      let(:datatable) { DatatableCondLteq.new(view) }
+      describe 'it can filter records with condition :end_with' do
+        let(:datatable) { DatatableCondEndWith.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, last_name: 'JOHN')
+          create(:user, last_name: 'MARY')
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = 2
-        expect(datatable.data.size).to eq 2
+        if ENV['DB_ADAPTER'] == 'oracle_enhanced'
+          context 'when db_adapter is oracleenhanced' do
+            it 'should filter records matching' do
+              datatable.params[:columns]['3'][:search][:value] = 'RY'
+              expect(datatable.data.size).to eq 1
+              item = datatable.data.first
+              expect(item[:last_name]).to eq 'MARY'
+            end
+          end
+        else
+          it 'should filter records matching' do
+            datatable.params[:columns]['3'][:search][:value] = 'ry'
+            expect(datatable.data.size).to eq 1
+            item = datatable.data.first
+            expect(item[:last_name]).to eq 'MARY'
+          end
+        end
       end
-    end
 
-    describe 'it can filter records with condition :gteq' do
-      let(:datatable) { DatatableCondGteq.new(view) }
+      describe 'it can filter records with condition :like' do
+        let(:datatable) { DatatableCondLike.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, email: 'john@foo.com')
+          create(:user, email: 'mary@bar.com')
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = 1
-        expect(datatable.data.size).to eq 2
+        it 'should filter records matching' do
+          datatable.params[:columns]['1'][:search][:value] = 'foo'
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:email]).to eq 'john@foo.com'
+        end
       end
-    end
 
-    describe 'it can filter records with condition :in' do
-      let(:datatable) { DatatableCondIn.new(view) }
+      describe 'it can filter records with condition :string_eq' do
+        let(:datatable) { DatatableCondStringEq.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-      end
+        before(:each) do
+          create(:user, email: 'john@foo.com')
+          create(:user, email: 'mary@bar.com')
+        end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = [1]
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'john'
+        it 'should filter records matching' do
+          datatable.params[:columns]['1'][:search][:value] = 'john@foo.com'
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:email]).to eq 'john@foo.com'
+        end
       end
-    end
 
-    describe 'it can filter records with condition :in with regex' do
-      let(:datatable) { DatatableCondInWithRegex.new(view) }
+      describe 'it can filter records with condition :string_in' do
+        let(:datatable) { DatatableCondStringIn.new(sample_params) }
 
-      before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
+        before(:each) do
+          create(:user, email: 'john@foo.com')
+          create(:user, email: 'mary@bar.com')
+          create(:user, email: 'henry@baz.com')
+        end
+
+        it 'should filter records matching' do
+          datatable.params[:columns]['1'][:search][:value] = 'john@foo.com'
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:email]).to eq 'john@foo.com'
+        end
+
+        it 'should filter records matching with multiple' do
+          datatable.params[:columns]['1'][:search][:value] = 'john@foo.com|henry@baz.com'
+          expect(datatable.data.size).to eq 2
+          items = datatable.data.sort_by { |h| h[:email] }
+          item_first = items.first
+          item_last = items.last
+          expect(item_first[:email]).to eq 'henry@baz.com'
+          expect(item_last[:email]).to eq 'john@foo.com'
+        end
+
+        it 'should filter records matching with multiple contains not found' do
+          datatable.params[:columns]['1'][:search][:value] = 'john@foo.com|henry_not@baz.com'
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:email]).to eq 'john@foo.com'
+        end
       end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['4'][:search][:value] = '1|2'
-        datatable.params[:order]['0'] = { column: '4', dir: 'asc' }
-        expect(datatable.data.size).to eq 2
-        item = datatable.data.first
-        expect(item[:first_name]).to eq 'john'
+      describe 'it can filter records with condition :null_value' do
+        let(:datatable) { DatatableCondNullValue.new(sample_params) }
+
+        before(:each) do
+          create(:user, first_name: 'john', email: 'foo@bar.com')
+          create(:user, first_name: 'mary', email: nil)
+        end
+
+        context 'when condition is NULL' do
+          it 'should filter records matching' do
+            datatable.params[:columns]['1'][:search][:value] = 'NULL'
+            expect(datatable.data.size).to eq 1
+            item = datatable.data.first
+            expect(item[:first_name]).to eq 'mary'
+          end
+        end
+
+        context 'when condition is !NULL' do
+          it 'should filter records matching' do
+            datatable.params[:columns]['1'][:search][:value] = '!NULL'
+            expect(datatable.data.size).to eq 1
+            item = datatable.data.first
+            expect(item[:first_name]).to eq 'john'
+          end
+        end
       end
     end
 
-    describe 'Integer overflows' do
-      let(:datatable) { DatatableCondEq.new(view) }
-      let(:largest_postgresql_integer_value) { 2147483647 }
-      let(:smallest_postgresql_integer_value) { -2147483648 }
+    context 'unknown condition' do
+      let(:datatable) { DatatableCondUnknown.new(sample_params) }
 
       before(:each) do
-        create(:user, first_name: 'john', post_id: 1)
-        create(:user, first_name: 'mary', post_id: 2)
-        create(:user, first_name: 'phil', post_id: largest_postgresql_integer_value)
+        datatable.params[:search] = { value: 'john doe', regex: 'false' }
       end
 
-      it 'Returns an empty result if input value is too large' do
-        datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value + 1
-        expect(datatable.data.size).to eq 0
+      it 'should raise error' do
+        expect {
+          datatable.data.size
+        }.to raise_error(AjaxDatatablesRails::Error::InvalidSearchCondition).with_message('foo')
       end
+    end
+  end
 
-      it 'Returns an empty result if input value is too small' do
-        datatable.params[:columns]['4'][:search][:value] = smallest_postgresql_integer_value - 1
-        expect(datatable.data.size).to eq 0
-      end
+  describe 'formatter option' do
+    let(:datatable) { DatatableWithFormater.new(sample_params) }
 
-      it 'returns the matching user' do
-        datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value
-        expect(datatable.data.size).to eq 1
-      end
+    before(:each) do
+      create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'DOE')
+      create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'SMITH')
+      datatable.params[:columns]['3'][:search][:value] = 'doe'
+    end
+
+    it 'can transform search value before asking the database' do
+      expect(datatable.data.size).to eq 1
+      item = datatable.data.first
+      expect(item[:last_name]).to eq 'DOE'
     end
   end
 end