datatables-net 0.4.0

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'AjaxDatatablesRails::Datatable::SimpleOrder' do
+  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({"column"=>"1", "dir"=>"desc"}) }
+  let(:simple_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new nil, options }
+
+  describe 'option methods' do
+    it 'sql query' do
+      expect(simple_order.query('firstname')).to eq('firstname DESC')
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+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

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

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe 'AjaxDatatablesRails::ORM::ActiveRecord#filter_records' do
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { ComplexDatatable.new(view) }
+
+  before(:each) do
+    AjaxDatatablesRails.configure do |config|
+      config.db_adapter = :sqlite
+      config.orm = :active_record
+    end
+
+    User.create(username: 'johndoe', email: 'johndoe@example.com')
+    User.create(username: 'msmith', email: 'mary.smith@example.com')
+  end
+
+  after(:each) do
+    User.destroy_all
+  end
+
+  describe 'filter records' do
+    let(:records) { User.all }
+
+    it 'requires a records collection as argument' do
+      expect { datatable.send(:filter_records) }.to raise_error
+    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)
+    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)
+    end
+
+    describe '#build_conditions_for_datatable' do
+      it 'returns an Arel object' do
+        datatable.params[:search] = { value: 'msmith' }
+        result = datatable.send(: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
+        end
+      end
+
+      context 'none of columns are connected' do
+        before(:each) do
+          allow(datatable).to receive(:searchable_columns) { [] }
+        end
+
+        it 'returns empty query result' do
+          datatable.params[:search] = { value: 'msmith' }
+          expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+        end
+      end
+
+      context 'with search query' do
+        before(:each) do
+          datatable.params[:search] = { value: "John", regex: "false" }
+        end
+
+        it 'returns a filtering query' do
+          query = datatable.send(:build_conditions_for_datatable)
+          results = records.where(query).map(&:username)
+          expect(results).to include('johndoe')
+          expect(results).not_to include('msmith')
+        end
+      end
+    end
+
+    describe '#build_conditions_for_selected_columns' do
+      context 'columns include search query' do
+        before do
+          datatable.params[:columns]['0'][:search][:value] = 'doe'
+          datatable.params[:columns]['1'][:search][:value] = 'example'
+        end
+
+        it 'returns an Arel object' do
+          result = datatable.send(:build_conditions_for_selected_columns)
+          expect(result).to be_a(Arel::Nodes::And)
+        end
+
+        it 'can call #to_sql on returned object' do
+          result = datatable.send(:build_conditions_for_selected_columns)
+          expect(result).to respond_to(:to_sql)
+          expect(result.to_sql).to eq(
+            "CAST(\"users\".\"username\" AS TEXT) LIKE '%doe%' AND CAST(\"users\".\"email\" AS TEXT) LIKE '%example%'"
+          )
+        end
+      end
+
+      it 'calls #build_conditions_for_selected_columns' do
+        expect(datatable).to receive(:build_conditions_for_selected_columns)
+        datatable.send(:build_conditions)
+      end
+
+      context 'with search values in columns' do
+        before(:each) do
+          datatable.params[:columns]['0'][:search][:value] = 'doe'
+        end
+
+        it 'returns a filtered set of records' do
+          query = datatable.send(:build_conditions_for_selected_columns)
+          results = records.where(query).map(&:username)
+          expect(results).to include('johndoe')
+          expect(results).not_to include('msmith')
+        end
+      end
+    end
+
+    describe '#typecast 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(:typecast)).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(:typecast)).to eq('VARCHAR')
+      end
+
+      it 'returns CHAR if :db_adapter is :mysql2' do
+        allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql2 }
+        expect(column.send(:typecast)).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(:typecast)).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(:typecast)).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(:typecast)).to eq('TEXT')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'AjaxDatatablesRails::ORM::ActiveRecord#paginate_records' do
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { SampleDatatable.new(view) }
+
+  before(:each) do
+    AjaxDatatablesRails.configure do |config|
+      config.db_adapter = :sqlite
+      config.orm = :active_record
+    end
+
+    User.create(username: 'johndoe', email: 'johndoe@example.com')
+    User.create(username: 'msmith', email: 'mary.smith@example.com')
+  end
+
+  after(:each) do
+    User.destroy_all
+  end
+
+  describe 'paginate records' do
+    let(:records) { User.all }
+
+    it 'requires a records collection argument' do
+      expect { datatable.send(:paginate_records) }.to raise_error
+    end
+
+    it 'paginates records properly' do
+      expect(datatable.send(:paginate_records, records).to_sql).to include(
+        "LIMIT 10 OFFSET 0"
+      )
+
+      datatable.params[:start] = "26"
+      datatable.params[:length] = "25"
+      expect(datatable.send(:paginate_records, records).to_sql).to include(
+        "LIMIT 25 OFFSET 25"
+      )
+    end
+
+    it 'depends on the value of #offset' do
+      expect(datatable.datatable).to receive(:offset)
+      datatable.send(:paginate_records, records)
+    end
+
+    it 'depends on the value of #per_page' do
+      expect(datatable.datatable).to receive(:per_page).at_least(:once) { 10 }
+      datatable.send(:paginate_records, records)
+    end
+  end
+end
+

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'AjaxDatatablesRails::ORM::ActiveRecord#sort_records' do
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { ComplexDatatable.new(view) }
+
+  before(:each) do
+    AjaxDatatablesRails.configure do |config|
+      config.db_adapter = :sqlite
+      config.orm = :active_record
+    end
+
+    User.create(username: 'johndoe', email: 'johndoe@example.com')
+    User.create(username: 'msmith', email: 'mary.smith@example.com')
+  end
+
+  after(:each) do
+    User.destroy_all
+  end
+
+  describe 'sort records' do
+    let(:records) { User.all }
+
+    it 'returns a records collection sorted by :order params' do
+      # set to order Users by email in descending order
+      datatable.params[:order]['0'] = { column: '1', dir: 'desc' }
+      expect(datatable.send(:sort_records, records).map(&:email)).to match(
+        ['mary.smith@example.com', 'johndoe@example.com']
+      )
+    end
+
+    it 'can handle multiple sorting columns' do
+      # set to order by Users username in ascending order, and
+      # by Users email in descending order
+      datatable.params[:order]['0'] = { column: '0', dir: 'asc' }
+      datatable.params[:order]['1'] = { column: '1', dir: 'desc' }
+      expect(datatable.send(:sort_records, records).to_sql).to include(
+        "ORDER BY users.username ASC, users.email DESC"
+      )
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'AjaxDatatablesRails::ORM::ActiveRecord#fetch_records' do
+  context 'Private API' do
+    let(:view) { double('view', params: sample_params) }
+    let(:datatable) { SampleDatatable.new(view) }
+
+    before(:each) do
+      AjaxDatatablesRails.configure do |config|
+        config.db_adapter = :sqlite
+        config.orm = :active_record
+      end
+
+      User.create(username: 'johndoe', email: 'johndoe@example.com')
+      User.create(username: 'msmith', email: 'mary.smith@example.com')
+    end
+
+    after(:each) do
+      User.destroy_all
+    end
+
+    describe 'fetch records' do
+      it 'calls #get_raw_records' do
+        expect(datatable).to receive(:get_raw_records) { User.all }
+        datatable.send(:fetch_records)
+      end
+
+      it 'returns a collection of records' do
+        expect(datatable).to receive(:get_raw_records) { User.all }
+        expect(datatable.send(:fetch_records)).to be_a(ActiveRecord::Relation)
+      end
+    end
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,43 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :users, :force => true do |t|
+    t.string :username
+    t.string :email
+    t.string :first_name
+    t.string :last_name
+
+    t.timestamps null: false
+  end
+
+  create_table :addresses, :force => true do |t|
+    t.string :address_line1
+    t.string :address_line2
+    t.string :city
+    t.string :zip_code
+    t.string :state
+    t.string :country
+
+    t.timestamps null: false
+  end
+
+  create_table :purchased_orders, :force => true do |t|
+    t.string :foo
+    t.string :bar
+
+    t.timestamps null: false
+  end
+
+  create_table :statistics_requests, :force => true do |t|
+    t.string :baz
+
+    t.timestamps null: false
+  end
+
+  create_table :statistics_sessions, :force => true do |t|
+    t.string :foo
+    t.integer :bar
+
+    t.timestamps null: false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'pry'
+require 'rails'
+require 'active_record'
+require 'ajax-datatables-rails'
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+load File.dirname(__FILE__) + '/schema.rb'
+load File.dirname(__FILE__) + '/test_helpers.rb'
+require File.dirname(__FILE__) + '/test_models.rb'

data/spec/test_helpers.rb

@@ -0,0 +1,66 @@
+def sample_params
+  ActiveSupport::HashWithIndifferentAccess.new(
+    {
+      "draw"=>"1",
+      "columns"=> {
+        "0"=> {
+          "data"=>"username", "name"=>"", "searchable"=>"true", "orderable"=>"true",
+          "search"=> {
+            "value"=>"", "regex"=>"false"
+          }
+        },
+        "1"=> {
+          "data"=>"email", "name"=>"", "searchable"=>"true", "orderable"=>"true",
+          "search"=> {
+            "value"=>"", "regex"=>"false"
+          }
+        },
+        "2"=> {
+          "data"=>"first_name", "name"=>"", "searchable"=>"false", "orderable"=>"false",
+          "search"=> {
+            "value"=>"", "regex"=>"false"
+          }
+        },
+        "3"=> {
+          "data"=>"last_name", "name"=>"", "searchable"=>"false", "orderable"=>"true",
+          "search"=> {
+            "value"=>"", "regex"=>"false"
+          }
+        },
+      },
+      "order"=> {
+        "0"=> {"column"=>"0", "dir"=>"asc"}
+      },
+      "start"=>"0", "length"=>"10", "search"=>{
+        "value"=>"", "regex"=>"false"
+      },
+      "_"=>"1423364387185"
+    }
+  )
+end
+
+class SampleDatatable < AjaxDatatablesRails::Base
+  def view_columns
+    @view_columns ||= ['User.username', 'User.email', 'User.first_name', 'User.last_name']
+  end
+
+  def data
+    [{}, {}]
+  end
+
+  def get_raw_records
+    User.all
+  end
+end
+
+
+class ComplexDatatable < SampleDatatable
+  def view_columns
+    @view_columns ||= {
+      username: { source: 'User.username' },
+      email: { source: 'User.email' },
+      first_name: { source: 'User.first_name' },
+      last_name: { source: 'User.last_name' }
+    }
+  end
+end

data/spec/test_models.rb

@@ -0,0 +1,20 @@
+class User < ActiveRecord::Base
+end
+
+class Address < ActiveRecord::Base
+end
+
+class PurchasedOrder < ActiveRecord::Base
+end
+
+module Statistics
+  def self.table_name_prefix
+    "statistics_"
+  end
+end
+
+class Statistics::Request < ActiveRecord::Base
+end
+
+class Statistics::Session < ActiveRecord::Base
+end