ajax-datatables-rails 0.4.3 → 1.3.1

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

@@ -1,58 +1,58 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe AjaxDatatablesRails::Datatable::Column do
+RSpec.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
 
     let(:column) { datatable.datatable.columns.first }
 
-    before do
-      datatable.params[:columns] = {'0'=>{'data'=>'username', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'searchvalue', 'regex'=>'false'}}}
-    end
+    before { datatable.params[:columns]['0'][:search][:value] = 'searchvalue' }
 
-    it 'should be orderable' do
+    it 'is orderable' do
       expect(column.orderable?).to eq(true)
     end
 
-    it 'should sort nulls last' do
+    it 'sorts nulls last' do
       expect(column.nulls_last?).to eq(false)
     end
 
-    it 'should be searchable' do
+    it 'is searchable' do
       expect(column.searchable?).to eq(true)
     end
 
-    it 'should be searched' do
+    it 'is searched' do
       expect(column.searched?).to eq(true)
     end
 
-    it 'should have connected to id column' do
+    it 'has connected to id column' do
       expect(column.data).to eq('username')
     end
 
     describe '#data' do
-      it 'should return the data from params' do
+      it 'returns the data from params' do
         expect(column.data).to eq 'username'
       end
     end
 
     describe '#source' do
-      it 'should return the data source from view_column' do
+      it 'returns the data source from view_column' do
         expect(column.source).to eq 'User.username'
       end
     end
 
     describe '#table' do
       context 'with ActiveRecord ORM' do
-        it 'should return the corresponding AR table' do
+        it 'returns the corresponding AR table' do
           expect(column.table).to eq User.arel_table
         end
       end
+
       context 'with other ORM' do
-        it 'should return the corresponding model' do
+        it 'returns the corresponding model' do
           expect(User).to receive(:respond_to?).with(:arel_table).and_return(false)
           expect(column.table).to eq User
         end
@@ -60,19 +60,19 @@ describe AjaxDatatablesRails::Datatable::Column do
     end
 
     describe '#model' do
-      it 'should return the corresponding AR model' do
+      it 'returns the corresponding AR model' do
         expect(column.model).to eq User
       end
     end
 
     describe '#field' do
-      it 'should return the corresponding field in DB' do
+      it 'returns the corresponding field in DB' do
         expect(column.field).to eq :username
       end
     end
 
     describe '#custom_field?' do
-      it 'should return false if field is bound to an AR field' do
+      it 'returns false if field is bound to an AR field' do
         expect(column.custom_field?).to be false
       end
     end
@@ -82,73 +82,141 @@ describe AjaxDatatablesRails::Datatable::Column do
         expect(column.search).to be_a(AjaxDatatablesRails::Datatable::SimpleSearch)
       end
 
-      it 'should have search value' do
+      it 'has search value' do
         expect(column.search.value).to eq('searchvalue')
       end
 
-      it 'should not regex' do
+      it 'does not regex' do
         expect(column.search.regexp?).to eq false
       end
     end
 
     describe '#cond' do
-      it 'should be :like by default' do
+      it 'is :like by default' do
         expect(column.cond).to eq(:like)
       end
     end
 
     describe '#source' do
-      it 'should be :like by default' do
+      it 'is :like by default' do
         expect(column.source).to eq('User.username')
       end
     end
 
     describe '#search_query' do
-      it 'should buld search query' do
+      it 'bulds search query' do
         expect(column.search_query.to_sql).to include('%searchvalue%')
       end
     end
 
     describe '#sort_query' do
-      it 'should build sort query' do
+      it 'builds sort query' do
         expect(column.sort_query).to eq('users.username')
       end
     end
 
     describe '#use_regex?' do
-      it 'should be true by default' do
+      it 'is true by default' do
         expect(column.use_regex?).to be true
       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 'is - 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)
+    it 'is a proc' do
+      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
+    it 'is 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 { datatable.params[:columns]['0'][:data] = '' }
+
+    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 { datatable.params[:columns]['0'][:data] = 'foo' }
+
+    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

@@ -1,22 +1,25 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe AjaxDatatablesRails::Datatable::Datatable do
+RSpec.describe AjaxDatatablesRails::Datatable::Datatable do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view).datatable }
-  let(:order_option) { {'0'=>{'column'=>'0', 'dir'=>'asc'}, '1'=>{'column'=>'1', 'dir'=>'desc'}} }
+  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
-    it 'should be orderable' do
+  shared_examples 'order methods' do
+    it 'is orderable' do
       expect(datatable.orderable?).to eq(true)
     end
 
-    it 'should not be orderable' do
+    it 'is not orderable' do
       datatable.options[:order] = nil
       expect(datatable.orderable?).to eq(false)
     end
 
-    it 'should have 2 orderable columns' do
+    it 'has 2 orderable columns' do
       datatable.options[:order] = order_option
       expect(datatable.orders.count).to eq(2)
     end
@@ -36,13 +39,35 @@ describe AjaxDatatablesRails::Datatable::Datatable do
     end
   end
 
+  shared_examples 'columns methods' do
+    it 'has 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
+    it 'is searchable' do
       datatable.options[:search][:value] = 'atom'
       expect(datatable.searchable?).to eq(true)
     end
 
-    it 'should not be searchable' do
+    it 'is not searchable' do
       datatable.options[:search][:value] = nil
       expect(datatable.searchable?).to eq(false)
     end
@@ -52,36 +77,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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe AjaxDatatablesRails::Datatable::SimpleOrder do
+RSpec.describe AjaxDatatablesRails::Datatable::SimpleOrder do
 
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ComplexDatatable.new(view).datatable }
-  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'column' => '1', 'dir' => 'desc'}) }
+  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) }
 
   describe 'option methods' do
@@ -14,27 +16,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