datatable 0.1.0alpha2

data/example_app/spec/datatables/active_record_dsl_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'Generating sql based on our DSL' do
+
+  # it 'should work' do
+  #   Order.create!(:order_number => 32)
+  #   datatable = OrdersIndex.new
+  #   params = {}
+  #   json = datatable.query(params).json
+  #   json['aaRecords'][0][0].should == 32
+  # end
+
+  it 'should select two fields' do
+    class OrdersSimple < Datatable::Base
+      set_model Order 
+
+      column :order_number
+      column :memo
+    end
+
+    orders = Order.arel_table
+    OrdersSimple.to_sql.should == Order.select(orders[:order_number]).select(orders[:memo]).to_sql
+    OrdersSimple.relation.should == Order.select(orders[:order_number]).select(orders[:memo])
+  end
+
+  it 'should handle a simple join' do
+    class OrdersSimple < Datatable::Base
+      set_model Order 
+
+      column :memo
+
+      join :customer
+    end
+
+    orders = Order.arel_table
+    OrdersSimple.to_sql.should == Order.select(orders[:memo]).joins(:customer).to_sql
+    OrdersSimple.relation.should == Order.select(orders[:memo]).joins(:customer)
+  end
+
+  it 'should handle a join with an inner column' do
+    class OrdersSimple < Datatable::Base
+      set_model Order 
+
+      column :memo
+
+      join :customer do
+        column :first_name
+      end
+
+    end
+
+    orders = Order.arel_table
+    customers = Arel::Table.new(:customers)
+    OrdersSimple.to_sql.should == Order.select(orders[:memo]).joins(:customer).select(customers[:first_name]).to_sql
+    OrdersSimple.relation.should == Order.select(orders[:memo]).joins(:customer).select(customers[:first_name])
+  end
+
+end
+

data/example_app/spec/datatables/active_record_link_to_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'adding links to active record datatables' do
+
+  before do
+    Object.send(:remove_const, :T) rescue nil
+    class T < Datatable::Base
+      set_model Order
+      column :id, :link_to => link_to('{{0}}', order_path('{{0}}'))
+    end
+    @params = {
+      'iColumns' => 1,
+      "bSearchable_0" => true
+    }
+  end
+
+  it "adding link_to in block adds it to the column" do
+    t = T.query(@params)
+    T.columns['orders.id'][:link_to].should == "<a href=\"/orders/%7B%7B0%7D%7D\">{{0}}</a>"
+  end
+
+end

data/example_app/spec/datatables/active_record_pagination_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe 'basic query params and pagination' do
+
+  before do
+    class OrdersSimple < Datatable::Base
+      set_model Order
+      column :id
+      column :memo
+      join :customer do
+        column :first_name
+      end
+    end
+    @params = {}
+
+    @params['iColumns'] = 3
+
+  end
+
+  it "sEcho" do
+    echo = rand(239823)
+    params = {'sEcho' => echo }
+    OrdersSimple.new(params).to_json['sEcho'].should == echo
+  end
+
+  it 'should return the number of records when there are no records' do
+    OrdersSimple.new.to_json['iTotalRecords'].should == 0
+    OrdersSimple.new.to_json['iTotalDisplayRecords'].should == 0
+  end
+
+  it 'should return the number of records' do
+    3.times{ Factory(:order) }
+    OrdersSimple.query(@params).to_json['iTotalRecords'].should == 3
+    OrdersSimple.query(@params).to_json['iTotalDisplayRecords'].should == 3
+  end
+
+  it 'should return valid aaData' do
+    class OrdersComplex < Datatable::Base
+      set_model Order
+      column :order_number
+      column :memo
+      join :customer do
+        column :first_name
+      end
+    end
+    @params['iColumns'] = 3
+
+    orders = [Factory(:order), Factory(:order)]
+    OrdersComplex.query(@params).to_json['aaData'].should == orders.map { |o| [o.order_number.to_s, o.memo, o.customer.first_name]}
+  end
+
+  it 'should return valid aaData in different order' do
+    class OrdersComplex < Datatable::Base
+      set_model Order
+      column :memo
+      column :order_number
+    end
+    @params['iColumns'] = 2
+    orders = [Factory(:order), Factory(:order)]
+    OrdersComplex.query(@params).to_json['aaData'].should == orders.map { |o| [o.memo, o.order_number.to_s]}
+  end
+
+  it "should provide first page" do
+    class OrdersComplex2 < Datatable::Base
+      set_model Order
+      column :id
+    end
+    @params['iColumns'] = 1
+
+    @params['iDisplayStart'] = 0
+    @params['iDisplayLength'] = 2
+    orders = [Factory(:order), Factory(:order), Factory(:order), Factory(:order)]
+    OrdersComplex2.query(@params).to_json['iTotalRecords'].should == 2
+    OrdersComplex2.query(@params).to_json['iTotalDisplayRecords'].should == 4
+    OrdersComplex2.query(@params).to_json['aaData'].should == orders[0..1].map {|o| [o.id.to_s] }
+  end
+
+  it "should provide second page" do
+     class OrdersComplex3 < Datatable::Base
+      set_model Order
+      column :id
+    end
+
+    @params['iColumns'] = 1
+    @params['iDisplayStart'] = 2
+    @params['iDisplayLength'] = 2
+
+    orders = [Factory(:order), Factory(:order), Factory(:order), Factory(:order)]
+    OrdersComplex3.query(@params).to_json['iTotalRecords'].should == 2
+    OrdersComplex3.query(@params).to_json['iTotalDisplayRecords'].should == 4
+    OrdersComplex3.query(@params).to_json['aaData'].should == Order.all[2..3].map {|o| [o.id.to_s] }
+  end
+
+end

data/example_app/spec/datatables/active_record_table_operations_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe 'Operations on the ActiveRecord table' do
+  # Store/ retrive:
+  #   data type 
+  #   ordering
+  #   human title
+
+
+  # Column sorting
+  #   input: an index to be sorted on
+  #     array of columns to sort on and asc/desc
+  #     [['asc', 1], ['desc', 3]]
+  #
+  #   need to know what index a column is
+  #   and from that index need to know the column name
+  #   sometimes will need the table name
+
+  # Pass in params for sorting by various columns in various orders
+  # Test that  records are returned in the correct order
+
+  before do
+    Object.send(:remove_const, :T) rescue nil
+
+    class T < Datatable::Base
+      set_model Order
+      column :id
+      column :order_number
+      column :memo
+    end
+
+    @params = {
+      "iColumns" =>	4,
+      "bSearchable_0" => true,
+      "bSearchable_1" => true,
+      "bSearchable_2" => true,
+      "bSearchable_3" => true,
+      "bSortable_0" => true,
+      "bSortable_1" => true,
+      "bSortable_2" => true,
+      "bSortable_3" => true,
+      "sSearch_0" => nil,
+      "sSearch_1" => nil,
+      "sSearch_2" => nil,
+      "sSearch_3" => nil,
+      "sSearch" => nil   }
+
+      Order.delete_all
+      @orders = [*0..20].map do 
+        Factory(:order, :order_number => rand(2), :memo => rand(2).even?  ? 'hello' : 'goodbye')
+      end
+  end
+
+  it 'should sort by one column' do
+    @params['iSortCol_0'] = 0
+    @params['sSortDir_0'] = 'desc' # Assume first col is ID
+    @params['iSortingCols'] = 1
+    T.query(@params).to_json['aaData'][0][0].should == Order.order("id desc").first.id.to_s
+  end
+
+  it 'should sort by multiple columns' do
+    @params['iSortCol_0'] = 2 # Memo
+    @params['sSortDir_0'] = 'asc' 
+
+    @params['iSortCol_1'] = 0 # ID
+    @params['sSortDir_1'] = 'desc' 
+
+    @params['iSortingCols'] = 2
+
+
+    T.query(@params).to_json['aaData'][0][0].should == Order.order('memo asc, id desc')[0].id.to_s
+    T.query(@params).to_json['aaData'][-1][0].should == Order.order('memo asc, id desc')[-1].id.to_s
+  end
+
+  it 'should sort ascending and descending' do
+    @params['iSortCol_0'] = 2 # Memo
+    @params['sSortDir_0'] = 'desc' 
+
+    @params['iSortCol_1'] = 0 # ID
+    @params['sSortDir_1'] = 'asc'
+
+    @params['iSortingCols'] = 2
+
+
+    T.query(@params).to_json['aaData'][0][0].should == Order.order('memo desc, id asc')[0].id.to_s
+    T.query(@params).to_json['aaData'][-1][0].should == Order.order('memo desc, id asc')[-1].id.to_s
+  end
+
+  # Multi column searching
+  #   input: a search term
+  #   a way to search on all of the columns that are searchable
+  #   need to know the datatype of whats in the columns
+  it 'should global search' do
+    # Assume memo and id are searchable
+    ## Pass in params for searching by the columns that are searchable
+    # Define which columns are searchable
+    # search using OR for each of those cols
+    # E.g. where int = num OR string LIKE str
+    # Types
+  end
+
+  it 'should global search string' do
+    # Memo is searchable
+    @params['sSearch'] = 'hel'
+    T.query(@params).to_json['aaData'][0][0].should == Order.where('memo LIKE ?', '%hel%')[0].id.to_s
+    T.query(@params).to_json['aaData'][0].map(&:first).should_not include(Order.where('memo NOT LIKE ?', '%hel%').map(&:id).map(&:to_s))
+  end
+
+  it 'should global search integer' do
+    # Id 
+    order_id =  Order.all[rand(Order.count)].id.to_s
+    @params['sSearch'] = order_id
+    T.query(@params).to_json['aaData'][0][0].should == order_id
+    T.query(@params).to_json['aaData'].length.should == 1
+  end
+
+  # Maybe: Test multiple results for integer
+
+  it 'should only search columns that are searchable' do
+    # ORder number is NOT searchable
+    # we need to make one value exist in 2 columsn for the test
+    # 
+    Order.last.update_attribute(:order_number, Order.first.id)
+    @params['bSearchable_1'] = false
+    @params['sSearch'] = Order.first.id
+    T.query(@params).to_json['aaData'][0][0].should == Order.first.id.to_s
+    T.query(@params).to_json['aaData'].length.should == 1
+  end
+
+  it "shouldn't barf when no columns are searchable" do
+    @params['bSearchable_0'] = false
+    @params['bSearchable_1'] = false
+    @params['bSearchable_2'] = false
+    @params['sSearch'] = "foo"
+    T.query(@params)
+  end
+
+  # TODO
+  # it 'should deal w/ dates'
+
+  # Individual column searching
+  #   input: index and a search term
+  #   need to know what index a col is and the col name
+  #   need to know the type
+  it 'should search by one string column' do
+    @params['bSearchable_2'] = true  # col2 = memo
+    @params['sSearch_2'] = "hello"
+    T.query(@params).to_json['aaData'].length.should == Order.where('memo LIKE ?', '%hello%').count
+    T.query(@params).to_json['aaData'].map { |r| r[2] }.uniq.should == ['hello']
+  end
+
+  it 'should search by one integer column' do
+    @params['bSearchable_1'] = true   
+    @params['sSearch_1'] = "1"
+    T.query(@params).to_json['aaData'].length.should == Order.where(:order_number => 1).count
+    T.query(@params).to_json['aaData'].map { |r| r[1] }.uniq.should == ["1"]
+  end
+
+  it 'should search by multiple columns' do
+    @params['bSearchable_1'] = true   
+    @params['sSearch_1'] = "1" 
+    @params['bSearchable_2'] = true   
+    @params['sSearch_2'] = "hello"
+    T.query(@params).to_json['aaData'].length.should == Order.where('memo LIKE ?', '%hello%').where(:order_number => 1).count
+    T.query(@params).to_json['aaData'].map { |r| r[2] }.uniq.should == ['hello']
+    T.query(@params).to_json['aaData'].map { |r| r[1] }.uniq.should == ["1"]
+  end
+
+  it 'only searches - when someone actually types 0'
+
+  # Column ordering (store/retrieve)
+  #   column names in order
+  #   sometimes will need to have the table name
+  #   ['col.table', 'col.table']
+  #   {'table.column' => :string, ...}
+  it 'should allow manually setting the order of columns'
+  it 'should otherwise automatically set the order' # E.g. arel
+
+end
+

data/example_app/spec/datatables/config_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'config' do
+  it "shouldn't blow up when I call Datatable.config" do
+    Datatable::Base.config do |config|
+      config.foo = "bar"
+    end
+    Datatable::Base.config.foo.should == "bar"
+  end
+end

data/example_app/spec/datatables/query_params_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe 'sanitize all parameters used in sql' do
+
+  before do
+    Object.send(:remove_const, :T) rescue nil
+    class T < Datatable::Base
+      sql <<-SQL
+        SELECT
+          id,
+          order_number,
+          memo
+        FROM
+          orders
+      SQL
+      columns(
+          {'orders.id'   => {:type => :integer}},
+          {'orders.order_number' => {:type => :integer }},
+          {'orders.memo' => {:type => :string }}
+      )
+    end
+
+    @params = {
+      "iColumns" =>	3,
+      "bSearchable_0" => false,
+      "bSearchable_1" => false,
+      "bSearchable_2" => false,
+      "bSortable_0" => false,
+      "bSortable_1" => false,
+      "bSortable_2" => false,
+      "sSearch_0" => nil,
+      "sSearch_1" => nil,
+      "sSearch_2" => nil,
+      "sSearch" => nil
+    }
+    Order.delete_all
+    20.times{ Factory(:order) }
+  end
+
+  it "sanitize sSearch" do
+    @params['sSearch'] = "'invalid sql"
+    T.query(@params).to_json
+    lambda{ T.query(@params) }.should_not raise_error
+  end
+
+  it "sanitize sSearch_#" do
+    @params['bSearchable_2'] = true
+    @params['sSearch_2'] = "'injected sql"
+    T.query(@params)
+    lambda{ T.query(@params) }.should_not raise_error
+  end
+
+  it "sanitize sSortDir_#" do
+    @params['sSortDir_2'] = "'injected sql"
+    T.query(@params).to_json
+    lambda{ T.query(@params) }.should_not raise_error
+  end
+
+  it "sanitize iDisplayLength" do
+    @params['iDisplayLength'] = "'injected sql"
+    lambda{ T.query(@params) }.should_not raise_error
+  end
+
+  it "sanitize iDisplayStart" do
+    @params['iDisplayStart'] = "'injected sql"
+    lambda{ T.query(@params) }.should_not raise_error
+  end
+
+
+
+
+
+end

data/example_app/spec/datatables/sql_default_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'default response intelligently when no arguments are provided' do
+
+  # it's useful to have the datable respond with the first page and without
+  # any errors when the json is browsed directly for debugging purposes
+
+  it "should return default page size" do
+    # don't return all data decide on default page size
+  end
+  
+  it "should not barf because iColumn is not set" do
+    # currently does
+  end
+
+  it "should be able to set the default sort direction" do
+    # most views will have an initially defined sort order
+    pending
+  end
+
+  
+end

data/example_app/spec/datatables/sql_pagination_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe 'pagination with count()' do
+
+  before do
+    Object.send(:remove_const, :T) rescue nil
+    class T < Datatable::Base
+      count("SELECT COUNT(*) + 100 FROM orders")
+      sql("SELECT id FROM orders")
+      columns({"orders.id" => {:type => :integer, :link_to => link_to('{{0}}', order_path('{{0}}')) }})
+    end
+    @params = {
+      'iColumns' => 1,
+      "bSearchable_0" => true
+    }
+    4.times{ Factory(:order) }
+  end
+
+  describe "first page" do
+    before do
+      @params['iDisplayStart'] = 0
+      @params['iDisplayLength'] = 2
+    end
+
+    it "iTotalRecords correctly set" do
+      T.query(@params).to_json['iTotalRecords'].should == 2
+    end
+
+    it "iTotalDisplayRecords correctly set" do
+      T.query(@params).to_json['iTotalDisplayRecords'].should == 104
+    end
+
+    it "aaData contains dataset" do
+      T.query(@params).to_json['aaData'].should == Order.all[0..1].map {|o| [o.id.to_s] }
+    end
+  end
+
+  describe "second page" do
+    before do
+      @params['iDisplayStart'] = 2
+      @params['iDisplayLength'] = 2
+    end
+
+    it "iTotalRecords correctly set" do
+      T.query(@params).to_json['iTotalRecords'].should == 2
+    end
+
+    it "iTotalDisplayRecords correctly set" do
+      T.query(@params).to_json['iTotalDisplayRecords'].should == 104
+    end
+
+    it "aaData contains dataset" do
+      T.query(@params).to_json['aaData'].should == Order.all[2..3].map {|o| [o.id.to_s] }
+    end
+  end
+end
+
+describe 'pagination without count()' do
+  
+  before do
+    Object.send(:remove_const, :T) rescue nil
+    class T < Datatable::Base
+      sql("SELECT id FROM orders")
+      columns({"orders.id" => {:type => :integer, :link_to => link_to('{{0}}', order_path('{{0}}')) }})
+    end
+    @params = {
+      'iColumns' => 1,
+      "bSearchable_0" => true
+    }
+    4.times{ Factory(:order) }
+  end
+
+  describe "first page" do
+    before do
+      @params['iDisplayStart'] = 0
+      @params['iDisplayLength'] = 2
+    end
+
+    it "iTotalRecords correctly set" do
+      T.query(@params).to_json['iTotalRecords'].should == 2
+    end
+
+    it "iTotalDisplayRecords correctly set" do
+      T.query(@params).to_json['iTotalDisplayRecords'].should == 4
+    end
+
+    it "aaData contains dataset" do
+      T.query(@params).to_json['aaData'].should == Order.all[0..1].map {|o| [o.id.to_s] }
+    end
+  end
+
+
+  describe "second page" do
+    before do
+      @params['iDisplayStart'] = 2
+      @params['iDisplayLength'] = 2
+    end
+    it "iTotalRecords correctly set" do
+      T.query(@params).to_json['iTotalRecords'].should == 2
+    end
+
+    it "iTotalDisplayRecords correctly set" do
+      T.query(@params).to_json['iTotalDisplayRecords'].should == 4
+    end
+
+    it "aaData contains dataset" do
+       T.query(@params).to_json['aaData'].should == Order.all[2..3].map {|o| [o.id.to_s] }
+    end
+  end
+
+end
+
+
+describe 'pagination with count() and where clause' do
+  before do
+    Object.send(:remove_const, :T) rescue nil
+    class T < Datatable::Base
+      count("SELECT COUNT(*) + 100 FROM orders")
+      sql("SELECT id FROM orders")
+      where("memo like 'foo'")
+      columns({"orders.id" => {:type => :integer, :link_to => link_to('{{0}}', order_path('{{0}}')) }})
+    end
+    @params = {
+      'iColumns' => 1,
+      "bSearchable_0" => true
+    }
+    Factory(:order, :memo => 'foo')
+    Factory(:order, :memo => 'foo')
+    Factory(:order, :memo => 'foo')
+    Factory(:order, :memo => 'bar')
+  end
+
+    describe "first page" do
+      before do
+        @params['iDisplayStart'] = 0
+        @params['iDisplayLength'] = 2
+      end
+
+      it "iTotalRecords correctly set" do
+        T.query(@params).to_json['iTotalRecords'].should == 2
+      end
+
+      it "iTotalDisplayRecords correctly set" do
+        result = T.query(@params).to_json['iTotalDisplayRecords']
+        result.should == 103
+      end
+
+      it "aaData contains dataset" do
+        expected = Order.where("memo like 'foo'").all[0..1].map {|o| [o.id.to_s] }.sort
+        actual = T.query(@params).to_json['aaData'].sort
+        actual.should == expected
+      end
+    end
+
+  describe "second page" do
+    before do
+      @params['iDisplayStart'] = 2
+      @params['iDisplayLength'] = 2
+    end
+
+    it "iTotalRecords correctly set" do
+      T.query(@params).to_json['iTotalRecords'].should == 1
+    end
+
+    it "iTotalDisplayRecords correctly set" do
+      T.query(@params).to_json['iTotalDisplayRecords'].should == 103
+    end
+
+    it "aaData contains dataset" do
+      expected = Order.where("memo like 'foo'").all[2..3].map {|o| [o.id.to_s] }.sort
+      actual = T.query(@params).to_json['aaData'].sort
+      actual.should == expected
+    end
+  end
+
+end
+

data/example_app/spec/datatables/sql_search_cast_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe "SQL defined datatable supports searching numbers as strings" do
+  pending "select id from orders where cast(id as text) like '%7%';"
+end
+