ajax-datatables-rails 0.3.1 → 1.4.0

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe AjaxDatatablesRails::Base do
+
+  describe 'an instance' 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(sample_params, foo: 'bar')
+      expect(datatable.options).to eq(foo: 'bar')
+    end
+  end
+
+  describe 'User API' do
+    describe '#view_columns' do
+      context 'when method is not defined by the user' do
+        it 'raises an error' do
+          datatable = described_class.new(sample_params)
+          expect { datatable.view_columns }.to raise_error NotImplementedError
+        end
+      end
+
+      context 'child class implements view_columns' do
+        it 'expects a hash based defining columns' do
+          datatable = ComplexDatatable.new(sample_params)
+          expect(datatable.view_columns).to be_a(Hash)
+        end
+      end
+    end
+
+    describe '#get_raw_records' do
+      context 'when method is not defined by the user' do
+        it 'raises an error' do
+          datatable = described_class.new(sample_params)
+          expect { datatable.get_raw_records }.to raise_error NotImplementedError
+        end
+      end
+    end
+
+    describe '#data' do
+      context 'when method is not defined by the user' do
+        it 'raises an error' do
+          datatable = described_class.new(sample_params)
+          expect { datatable.data }.to raise_error NotImplementedError
+        end
+      end
+
+      context 'when data is defined as a hash' do
+        let(:datatable) { ComplexDatatable.new(sample_params) }
+
+        it 'returns an array of hashes' do
+          create_list(:user, 5)
+          expect(datatable.data).to be_a(Array)
+          expect(datatable.data.size).to eq 5
+          item = datatable.data.first
+          expect(item).to be_a(Hash)
+        end
+
+        it 'htmls escape data' do
+          create(:user, first_name: 'Name "><img src=x onerror=alert("first_name")>', last_name: 'Name "><img src=x onerror=alert("last_name")>')
+          data = datatable.send(:sanitize_data, datatable.data)
+          item = data.first
+          expect(item[:first_name]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;first_name&quot;)&gt;'
+          expect(item[:last_name]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;last_name&quot;)&gt;'
+        end
+      end
+
+      context 'when data is defined as a array' do
+        let(:datatable) { ComplexDatatableArray.new(sample_params) }
+
+        it 'returns an array of arrays' do
+          create_list(:user, 5)
+          expect(datatable.data).to be_a(Array)
+          expect(datatable.data.size).to eq 5
+          item = datatable.data.first
+          expect(item).to be_a(Array)
+        end
+
+        it 'htmls escape data' do
+          create(:user, first_name: 'Name "><img src=x onerror=alert("first_name")>', last_name: 'Name "><img src=x onerror=alert("last_name")>')
+          data = datatable.send(:sanitize_data, datatable.data)
+          item = data.first
+          expect(item[2]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;first_name&quot;)&gt;'
+          expect(item[3]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;last_name&quot;)&gt;'
+        end
+      end
+    end
+  end
+
+  describe 'ORM 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 NotImplementedError
+        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 NotImplementedError
+        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 NotImplementedError
+        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 NotImplementedError
+        end
+      end
+    end
+
+    context 'when ORM is implemented' do
+      describe 'it allows method override' do
+        let(:datatable) do
+          datatable = Class.new(ComplexDatatable) do
+            def filter_records(records)
+              raise NotImplementedError.new('FOO')
+            end
+
+            def sort_records(records)
+              raise NotImplementedError.new('FOO')
+            end
+
+            def paginate_records(records)
+              raise NotImplementedError.new('FOO')
+            end
+          end
+          datatable.new(sample_params)
+        end
+
+        describe '#fetch_records' do
+          it 'calls #get_raw_records' do
+            expect(datatable).to receive(:get_raw_records) { User.all }
+            datatable.fetch_records
+          end
+
+          it 'returns a collection of records' do
+            expect(datatable).to receive(:get_raw_records) { User.all }
+            expect(datatable.fetch_records).to be_a(ActiveRecord::Relation)
+          end
+        end
+
+        describe '#filter_records' do
+          it {
+            expect { datatable.filter_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
+        end
+
+        describe '#sort_records' do
+          it {
+            expect { datatable.sort_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
+        end
+
+        describe '#paginate_records' do
+          it {
+            expect { datatable.paginate_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
+        end
+      end
+    end
+  end
+
+  describe 'JSON format' do
+    describe '#as_json' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
+
+      it 'returns a hash' do
+        create_list(:user, 5)
+        data = datatable.as_json
+        expect(data[:recordsTotal]).to eq 5
+        expect(data[:recordsFiltered]).to eq 5
+        expect(data[:data]).to be_a(Array)
+        expect(data[:data].size).to eq 5
+      end
+
+      context 'with additional_data' do
+        it 'returns a hash' do
+          create_list(:user, 5)
+          expect(datatable).to receive(:additional_data) { { foo: 'bar' } }
+          data = datatable.as_json
+          expect(data[:recordsTotal]).to eq 5
+          expect(data[:recordsFiltered]).to eq 5
+          expect(data[:data]).to be_a(Array)
+          expect(data[:data].size).to eq 5
+          expect(data[:foo]).to eq 'bar'
+        end
+      end
+    end
+  end
+
+  describe 'User helper methods' do
+    describe '#column_id' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
+
+      it 'returns column id from view_columns hash' do
+        expect(datatable.column_id(:username)).to eq(0)
+        expect(datatable.column_id('username')).to eq(0)
+      end
+    end
+
+    describe '#column_data' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
+      before { datatable.params[:columns]['0'][:search][:value] = 'doe' }
+
+      it 'returns column data from params' do
+        expect(datatable.column_data(:username)).to eq('doe')
+        expect(datatable.column_data('username')).to eq('doe')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe AjaxDatatablesRails::Datatable::Column do
+
+  let(:datatable) { ComplexDatatable.new(sample_params) }
+
+  describe 'username column' do
+
+    let(:column) { datatable.datatable.columns.first }
+
+    before { datatable.params[:columns]['0'][:search][:value] = 'searchvalue' }
+
+    it 'is orderable' do
+      expect(column.orderable?).to eq(true)
+    end
+
+    it 'sorts nulls last' do
+      expect(column.nulls_last?).to eq(false)
+    end
+
+    it 'is searchable' do
+      expect(column.searchable?).to eq(true)
+    end
+
+    it 'is searched' do
+      expect(column.searched?).to eq(true)
+    end
+
+    it 'has connected to id column' do
+      expect(column.data).to eq('username')
+    end
+
+    describe '#data' do
+      it 'returns the data from params' do
+        expect(column.data).to eq 'username'
+      end
+    end
+
+    describe '#source' 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 'returns the corresponding AR table' do
+          expect(column.table).to eq User.arel_table
+        end
+      end
+
+      context 'with other ORM' 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
+      end
+    end
+
+    describe '#model' do
+      it 'returns the corresponding AR model' do
+        expect(column.model).to eq User
+      end
+    end
+
+    describe '#field' do
+      it 'returns the corresponding field in DB' do
+        expect(column.field).to eq :username
+      end
+    end
+
+    describe '#custom_field?' do
+      it 'returns false if field is bound to an AR field' do
+        expect(column.custom_field?).to be false
+      end
+    end
+
+    describe '#search' do
+      it 'child class' do
+        expect(column.search).to be_a(AjaxDatatablesRails::Datatable::SimpleSearch)
+      end
+
+      it 'has search value' do
+        expect(column.search.value).to eq('searchvalue')
+      end
+
+      it 'does not regex' do
+        expect(column.search.regexp?).to eq false
+      end
+    end
+
+    describe '#cond' do
+      it 'is :like by default' do
+        expect(column.cond).to eq(:like)
+      end
+    end
+
+    describe '#source' do
+      it 'is :like by default' do
+        expect(column.source).to eq('User.username')
+      end
+    end
+
+    describe '#search_query' do
+      it 'bulds search query' do
+        expect(column.search_query.to_sql).to include('%searchvalue%')
+      end
+    end
+
+    describe '#sort_query' do
+      it 'builds sort query' do
+        expect(column.sort_query).to eq('users.username')
+      end
+    end
+
+    describe '#use_regex?' do
+      it 'is true by default' do
+        expect(column.use_regex?).to be true
+      end
+    end
+
+    describe '#delimiter' do
+      it 'is - by default' do
+        expect(column.delimiter).to eq('-')
+      end
+    end
+  end
+
+  describe '#formatter' do
+    let(:datatable) { DatatableWithFormater.new(sample_params) }
+    let(:column) { datatable.datatable.columns.find { |c| c.data == 'last_name' } }
+
+    it 'is a proc' do
+      expect(column.formatter).to be_a(Proc)
+    end
+  end
+
+  describe '#filter' do
+    let(:datatable) { DatatableCondProc.new(sample_params) }
+    let(:column) { datatable.datatable.columns.find { |c| c.data == 'username' } }
+
+    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.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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe AjaxDatatablesRails::Datatable::Datatable do
+
+  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' }] }
+
+  shared_examples 'order methods' do
+    it 'is orderable' do
+      expect(datatable.orderable?).to eq(true)
+    end
+
+    it 'is not orderable' do
+      datatable.options[:order] = nil
+      expect(datatable.orderable?).to eq(false)
+    end
+
+    it 'has 2 orderable columns' do
+      datatable.options[:order] = order_option
+      expect(datatable.orders.count).to eq(2)
+    end
+
+    it 'first column ordered by ASC' do
+      datatable.options[:order] = order_option
+      expect(datatable.orders.first.direction).to eq('ASC')
+    end
+
+    it 'first column ordered by DESC' do
+      datatable.options[:order] = order_option
+      expect(datatable.orders.last.direction).to eq('DESC')
+    end
+
+    it 'child class' do
+      expect(datatable.orders.first).to be_a(AjaxDatatablesRails::Datatable::SimpleOrder)
+    end
+  end
+
+  shared_examples 'columns methods' do
+    it 'has 7 columns' do
+      expect(datatable.columns.count).to eq(7)
+    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 'is searchable' do
+      datatable.options[:search][:value] = 'atom'
+      expect(datatable.searchable?).to eq(true)
+    end
+
+    it 'is not searchable' do
+      datatable.options[:search][:value] = nil
+      expect(datatable.searchable?).to eq(false)
+    end
+
+    it 'child class' do
+      expect(datatable.search).to be_a(AjaxDatatablesRails::Datatable::SimpleSearch)
+    end
+  end
+
+  describe 'option methods' do
+    describe '#paginate?' do
+      it {
+        expect(datatable.paginate?).to be(true)
+      }
+    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
+
+      context 'when params[:length] is passed' do
+        let(:datatable) { ComplexDatatable.new({ length: '20' }).datatable }
+
+        it 'matches the value on view params[:length]' do
+          expect(datatable.per_page).to eq(20)
+        end
+      end
+    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 'matches the value on view params[:start]' do
+          expect(datatable.offset).to eq(11)
+        end
+      end
+    end
+
+    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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe AjaxDatatablesRails::Datatable::SimpleOrder do
+
+  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
+    it 'sql query' do
+      expect(simple_order.query('firstname')).to eq('firstname DESC')
+    end
+  end
+
+  describe 'option methods with nulls last' do
+    describe 'using class option' do
+      before { parent.nulls_last = true }
+      after  { parent.nulls_last = false }
+
+      it 'sql query' do
+        skip('unsupported database adapter') if RunningSpec.oracle?
+
+        expect(simple_order.query('email')).to eq(
+          "email DESC #{nulls_last_sql(parent)}"
+        )
+      end
+    end
+
+    describe 'using column option' do
+      let(:parent) { DatatableOrderNullsLast.new(sample_params) }
+      let(:sorted_datatable) { parent.datatable }
+      let(:nulls_last_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(sorted_datatable, options) }
+
+      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/datatable/simple_search_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe AjaxDatatablesRails::Datatable::SimpleSearch do
+
+  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({ 'value' => 'search value', 'regex' => 'true' }) }
+  let(:simple_search) { AjaxDatatablesRails::Datatable::SimpleSearch.new(options) }
+
+  describe 'option methods' do
+    it 'regexp?' do
+      expect(simple_search.regexp?).to be(true)
+    end
+
+    it 'value' do
+      expect(simple_search.value).to eq('search value')
+    end
+  end
+end