ajax-datatables-rails 0.4.3 → 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (72) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +120 -0
  3. data/.rubocop.yml +17 -7
  4. data/Appraisals +15 -20
  5. data/CHANGELOG.md +54 -1
  6. data/Gemfile +0 -5
  7. data/Guardfile +16 -0
  8. data/README.md +238 -112
  9. data/Rakefile +1 -0
  10. data/ajax-datatables-rails.gemspec +24 -20
  11. data/bin/_guard-core +29 -0
  12. data/bin/appraisal +29 -0
  13. data/bin/bundle +114 -0
  14. data/bin/guard +29 -0
  15. data/bin/rake +29 -0
  16. data/bin/rspec +29 -0
  17. data/bin/rubocop +29 -0
  18. data/doc/migrate.md +97 -0
  19. data/doc/webpack.md +7 -2
  20. data/gemfiles/{rails_5.2.0.gemfile → rails_5.2.4.gemfile} +3 -5
  21. data/gemfiles/{rails_5.0.7.gemfile → rails_6.0.3.gemfile} +4 -6
  22. data/gemfiles/{rails_5.1.6.gemfile → rails_6.1.0.gemfile} +4 -6
  23. data/lib/ajax-datatables-rails.rb +12 -1
  24. data/lib/ajax-datatables-rails/active_record.rb +7 -0
  25. data/lib/ajax-datatables-rails/base.rb +47 -46
  26. data/lib/ajax-datatables-rails/datatable.rb +6 -0
  27. data/lib/ajax-datatables-rails/datatable/column.rb +65 -20
  28. data/lib/ajax-datatables-rails/datatable/column/date_filter.rb +12 -21
  29. data/lib/ajax-datatables-rails/datatable/column/order.rb +1 -1
  30. data/lib/ajax-datatables-rails/datatable/column/search.rb +37 -22
  31. data/lib/ajax-datatables-rails/datatable/datatable.rb +16 -7
  32. data/lib/ajax-datatables-rails/datatable/simple_order.rb +23 -10
  33. data/lib/ajax-datatables-rails/datatable/simple_search.rb +2 -0
  34. data/lib/ajax-datatables-rails/error.rb +9 -0
  35. data/lib/ajax-datatables-rails/orm.rb +6 -0
  36. data/lib/ajax-datatables-rails/orm/active_record.rb +11 -12
  37. data/lib/ajax-datatables-rails/version.rb +13 -1
  38. data/lib/generators/rails/templates/datatable.rb +1 -1
  39. data/spec/ajax-datatables-rails/base_spec.rb +129 -93
  40. data/spec/ajax-datatables-rails/datatable/column_spec.rb +105 -37
  41. data/spec/ajax-datatables-rails/datatable/datatable_spec.rb +71 -31
  42. data/spec/ajax-datatables-rails/datatable/simple_order_spec.rb +36 -14
  43. data/spec/ajax-datatables-rails/datatable/simple_search_spec.rb +4 -2
  44. data/spec/ajax-datatables-rails/orm/active_record_filter_records_spec.rb +315 -272
  45. data/spec/ajax-datatables-rails/orm/active_record_paginate_records_spec.rb +9 -8
  46. data/spec/ajax-datatables-rails/orm/active_record_sort_records_spec.rb +17 -14
  47. data/spec/factories/user.rb +3 -1
  48. data/spec/install_oracle.sh +9 -3
  49. data/spec/spec_helper.rb +33 -28
  50. data/spec/support/datatables/complex_datatable.rb +31 -0
  51. data/spec/support/datatables/complex_datatable_array.rb +16 -0
  52. data/spec/support/{datatable_cond_date.rb → datatables/datatable_cond_date.rb} +2 -0
  53. data/spec/support/{datatable_cond_numeric.rb → datatables/datatable_cond_numeric.rb} +3 -1
  54. data/spec/support/{datatable_cond_proc.rb → datatables/datatable_cond_proc.rb} +2 -0
  55. data/spec/support/{datatable_cond_string.rb → datatables/datatable_cond_string.rb} +9 -1
  56. data/spec/support/datatables/datatable_cond_unknown.rb +7 -0
  57. data/spec/support/{datatable_order_nulls_last.rb → datatables/datatable_order_nulls_last.rb} +2 -0
  58. data/spec/support/{test_helpers.rb → helpers/params.rb} +17 -42
  59. data/spec/support/{test_models.rb → models/user.rb} +2 -0
  60. data/spec/support/schema.rb +3 -1
  61. metadata +76 -75
  62. data/.travis.yml +0 -80
  63. data/gemfiles/rails_4.0.13.gemfile +0 -14
  64. data/gemfiles/rails_4.1.16.gemfile +0 -14
  65. data/gemfiles/rails_4.2.10.gemfile +0 -14
  66. data/lib/ajax-datatables-rails/config.rb +0 -31
  67. data/lib/ajax_datatables_rails.rb +0 -15
  68. data/lib/generators/datatable/config_generator.rb +0 -19
  69. data/lib/generators/datatable/templates/ajax_datatables_rails_config.rb +0 -12
  70. data/spec/ajax-datatables-rails/configuration_spec.rb +0 -43
  71. data/spec/ajax-datatables-rails/extended_spec.rb +0 -20
  72. data/spec/ajax-datatables-rails/orm/active_record_spec.rb +0 -25
@@ -1,8 +1,10 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require 'spec_helper'
2
4
 
3
- describe AjaxDatatablesRails::Datatable::SimpleSearch do
5
+ RSpec.describe AjaxDatatablesRails::Datatable::SimpleSearch do
4
6
 
5
- let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'value' => 'search value', 'regex' => 'true'}) }
7
+ let(:options) { ActiveSupport::HashWithIndifferentAccess.new({ 'value' => 'search value', 'regex' => 'true' }) }
6
8
  let(:simple_search) { AjaxDatatablesRails::Datatable::SimpleSearch.new(options) }
7
9
 
8
10
  describe 'option methods' do
@@ -1,80 +1,104 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require 'spec_helper'
2
4
 
3
- describe AjaxDatatablesRails::ORM::ActiveRecord do
5
+ RSpec.describe AjaxDatatablesRails::ORM::ActiveRecord do
4
6
 
5
- let(:view) { double('view', params: sample_params) }
6
- let(:datatable) { ComplexDatatable.new(view) }
7
+ let(:datatable) { ComplexDatatable.new(sample_params) }
7
8
  let(:records) { User.all }
8
9
 
9
10
  describe '#filter_records' do
10
11
  it 'requires a records collection as argument' do
11
- expect { datatable.send(:filter_records) }.to raise_error(ArgumentError)
12
+ expect { datatable.filter_records }.to raise_error(ArgumentError)
12
13
  end
13
14
 
14
15
  it 'performs a simple search first' do
15
16
  datatable.params[:search] = { value: 'msmith' }
16
17
  expect(datatable).to receive(:build_conditions_for_datatable)
17
- datatable.send(:filter_records, records)
18
+ datatable.filter_records(records)
18
19
  end
19
20
 
20
21
  it 'performs a composite search second' do
21
22
  datatable.params[:search] = { value: '' }
22
23
  expect(datatable).to receive(:build_conditions_for_selected_columns)
23
- datatable.send(:filter_records, records)
24
+ datatable.filter_records(records)
25
+ end
26
+ end
27
+
28
+ describe '#build_conditions' do
29
+ before do
30
+ create(:user, username: 'johndoe', email: 'johndoe@example.com')
31
+ create(:user, username: 'msmith', email: 'mary.smith@example.com')
32
+ create(:user, username: 'hsmith', email: 'henry.smith@example.net')
33
+ end
34
+
35
+ context 'with column and global search' do
36
+ before do
37
+ datatable.params[:search] = { value: 'example.com', regex: 'false' }
38
+ datatable.params[:columns]['0'][:search][:value] = 'smith'
39
+ end
40
+
41
+ it 'return a filtered set of records' do
42
+ query = datatable.build_conditions
43
+ results = records.where(query).map(&:username)
44
+ expect(results).to include('msmith')
45
+ expect(results).not_to include('johndoe')
46
+ expect(results).not_to include('hsmith')
47
+ end
24
48
  end
25
49
  end
26
50
 
27
51
  describe '#build_conditions_for_datatable' do
28
- before(:each) do
52
+ before do
29
53
  create(:user, username: 'johndoe', email: 'johndoe@example.com')
30
54
  create(:user, username: 'msmith', email: 'mary.smith@example.com')
31
55
  end
32
56
 
33
57
  it 'returns an Arel object' do
34
58
  datatable.params[:search] = { value: 'msmith' }
35
- result = datatable.send(:build_conditions_for_datatable)
59
+ result = datatable.build_conditions_for_datatable
36
60
  expect(result).to be_a(Arel::Nodes::Grouping)
37
61
  end
38
62
 
39
63
  context 'no search query' do
40
64
  it 'returns empty query' do
41
65
  datatable.params[:search] = { value: '' }
42
- expect(datatable.send(:build_conditions_for_datatable)).to be_blank
66
+ expect(datatable.build_conditions_for_datatable).to be_blank
43
67
  end
44
68
  end
45
69
 
46
70
  context 'when none of columns are connected' do
47
- before(:each) do
71
+ before do
48
72
  allow(datatable).to receive(:searchable_columns) { [] }
49
73
  end
50
74
 
51
75
  context 'when search value is a string' do
52
- before(:each) do
76
+ before do
53
77
  datatable.params[:search] = { value: 'msmith' }
54
78
  end
55
79
 
56
80
  it 'returns empty query result' do
57
- expect(datatable.send(:build_conditions_for_datatable)).to be_blank
81
+ expect(datatable.build_conditions_for_datatable).to be_blank
58
82
  end
59
83
 
60
84
  it 'returns filtered results' do
61
- query = datatable.send(:build_conditions_for_datatable)
85
+ query = datatable.build_conditions_for_datatable
62
86
  results = records.where(query).map(&:username)
63
87
  expect(results).to eq ['johndoe', 'msmith']
64
88
  end
65
89
  end
66
90
 
67
91
  context 'when search value is space-separated string' do
68
- before(:each) do
92
+ before do
69
93
  datatable.params[:search] = { value: 'foo bar' }
70
94
  end
71
95
 
72
96
  it 'returns empty query result' do
73
- expect(datatable.send(:build_conditions_for_datatable)).to be_blank
97
+ expect(datatable.build_conditions_for_datatable).to be_blank
74
98
  end
75
99
 
76
100
  it 'returns filtered results' do
77
- query = datatable.send(:build_conditions_for_datatable)
101
+ query = datatable.build_conditions_for_datatable
78
102
  results = records.where(query).map(&:username)
79
103
  expect(results).to eq ['johndoe', 'msmith']
80
104
  end
@@ -83,12 +107,12 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
83
107
 
84
108
  context 'with search query' do
85
109
  context 'when search value is a string' do
86
- before(:each) do
110
+ before do
87
111
  datatable.params[:search] = { value: 'john', regex: 'false' }
88
112
  end
89
113
 
90
114
  it 'returns a filtering query' do
91
- query = datatable.send(:build_conditions_for_datatable)
115
+ query = datatable.build_conditions_for_datatable
92
116
  results = records.where(query).map(&:username)
93
117
  expect(results).to include('johndoe')
94
118
  expect(results).not_to include('msmith')
@@ -96,22 +120,39 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
96
120
  end
97
121
 
98
122
  context 'when search value is space-separated string' do
99
- before(:each) do
123
+ before do
100
124
  datatable.params[:search] = { value: 'john doe', regex: 'false' }
101
125
  end
102
126
 
103
127
  it 'returns a filtering query' do
104
- query = datatable.send(:build_conditions_for_datatable)
128
+ query = datatable.build_conditions_for_datatable
105
129
  results = records.where(query).map(&:username)
106
130
  expect(results).to eq ['johndoe']
107
131
  expect(results).not_to include('msmith')
108
132
  end
109
133
  end
134
+
135
+ # TODO: improve (or delete?) this test
136
+ context 'when column.search_query returns nil' do
137
+ let(:datatable) { DatatableCondUnknown.new(sample_params) }
138
+
139
+ before do
140
+ datatable.params[:search] = { value: 'john doe', regex: 'false' }
141
+ end
142
+
143
+ it 'does not raise error' do
144
+ allow_any_instance_of(AjaxDatatablesRails::Datatable::Column).to receive(:valid_search_condition?).and_return(true)
145
+
146
+ expect {
147
+ datatable.data.size
148
+ }.to_not raise_error
149
+ end
150
+ end
110
151
  end
111
152
  end
112
153
 
113
154
  describe '#build_conditions_for_selected_columns' do
114
- before(:each) do
155
+ before do
115
156
  create(:user, username: 'johndoe', email: 'johndoe@example.com')
116
157
  create(:user, username: 'msmith', email: 'mary.smith@example.com')
117
158
  end
@@ -123,14 +164,14 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
123
164
  end
124
165
 
125
166
  it 'returns an Arel object' do
126
- result = datatable.send(:build_conditions_for_selected_columns)
167
+ result = datatable.build_conditions_for_selected_columns
127
168
  expect(result).to be_a(Arel::Nodes::And)
128
169
  end
129
170
 
130
- if AjaxDatatablesRails.config.db_adapter == :postgresql
171
+ if ENV['DB_ADAPTER'] == 'postgresql'
131
172
  context 'when db_adapter is postgresql' do
132
173
  it 'can call #to_sql on returned object' do
133
- result = datatable.send(:build_conditions_for_selected_columns)
174
+ result = datatable.build_conditions_for_selected_columns
134
175
  expect(result).to respond_to(:to_sql)
135
176
  expect(result.to_sql).to eq(
136
177
  "CAST(\"users\".\"username\" AS VARCHAR) ILIKE '%doe%' AND CAST(\"users\".\"email\" AS VARCHAR) ILIKE '%example%'"
@@ -139,10 +180,10 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
139
180
  end
140
181
  end
141
182
 
142
- if AjaxDatatablesRails.config.db_adapter.in? %i[oracle oracleenhanced]
183
+ if ENV['DB_ADAPTER'] == 'oracle_enhanced'
143
184
  context 'when db_adapter is oracle' do
144
185
  it 'can call #to_sql on returned object' do
145
- result = datatable.send(:build_conditions_for_selected_columns)
186
+ result = datatable.build_conditions_for_selected_columns
146
187
  expect(result).to respond_to(:to_sql)
147
188
  expect(result.to_sql).to eq(
148
189
  "CAST(\"USERS\".\"USERNAME\" AS VARCHAR2(4000)) LIKE '%doe%' AND CAST(\"USERS\".\"EMAIL\" AS VARCHAR2(4000)) LIKE '%example%'"
@@ -151,10 +192,10 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
151
192
  end
152
193
  end
153
194
 
154
- if AjaxDatatablesRails.config.db_adapter.in? %i[mysql2 sqlite3]
195
+ if ENV['DB_ADAPTER'] == 'mysql2'
155
196
  context 'when db_adapter is mysql2' do
156
197
  it 'can call #to_sql on returned object' do
157
- result = datatable.send(:build_conditions_for_selected_columns)
198
+ result = datatable.build_conditions_for_selected_columns
158
199
  expect(result).to respond_to(:to_sql)
159
200
  expect(result.to_sql).to eq(
160
201
  "CAST(`users`.`username` AS CHAR) LIKE '%doe%' AND CAST(`users`.`email` AS CHAR) LIKE '%example%'"
@@ -166,16 +207,16 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
166
207
 
167
208
  it 'calls #build_conditions_for_selected_columns' do
168
209
  expect(datatable).to receive(:build_conditions_for_selected_columns)
169
- datatable.send(:build_conditions)
210
+ datatable.build_conditions
170
211
  end
171
212
 
172
213
  context 'with search values in columns' do
173
- before(:each) do
214
+ before do
174
215
  datatable.params[:columns]['0'][:search][:value] = 'doe'
175
216
  end
176
217
 
177
218
  it 'returns a filtered set of records' do
178
- query = datatable.send(:build_conditions_for_selected_columns)
219
+ query = datatable.build_conditions_for_selected_columns
179
220
  results = records.where(query).map(&:username)
180
221
  expect(results).to include('johndoe')
181
222
  expect(results).not_to include('msmith')
@@ -183,68 +224,18 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
183
224
  end
184
225
  end
185
226
 
186
- describe '#type_cast helper method' do
187
- let(:view) { double('view', params: sample_params) }
188
- let(:column) { ComplexDatatable.new(view).datatable.columns.first }
189
-
190
- it 'returns VARCHAR if :db_adapter is :pg' do
191
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :pg }
192
- expect(column.send(:type_cast)).to eq('VARCHAR')
193
- end
194
-
195
- it 'returns VARCHAR if :db_adapter is :postgre' do
196
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgre }
197
- expect(column.send(:type_cast)).to eq('VARCHAR')
198
- end
199
-
200
- it 'returns VARCHAR if :db_adapter is :postgresql' do
201
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgresql }
202
- expect(column.send(:type_cast)).to eq('VARCHAR')
203
- end
204
-
205
- it 'returns VARCHAR if :db_adapter is :oracle' do
206
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracle }
207
- expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
208
- end
209
-
210
- it 'returns VARCHAR if :db_adapter is :oracleenhanced' do
211
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracleenhanced }
212
- expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
213
- end
214
-
215
- it 'returns CHAR if :db_adapter is :mysql2' do
216
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql2 }
217
- expect(column.send(:type_cast)).to eq('CHAR')
218
- end
219
-
220
- it 'returns CHAR if :db_adapter is :mysql' do
221
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql }
222
- expect(column.send(:type_cast)).to eq('CHAR')
223
- end
224
-
225
- it 'returns TEXT if :db_adapter is :sqlite' do
226
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite }
227
- expect(column.send(:type_cast)).to eq('TEXT')
228
- end
229
-
230
- it 'returns TEXT if :db_adapter is :sqlite3' do
231
- allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite3 }
232
- expect(column.send(:type_cast)).to eq('TEXT')
233
- end
234
- end
235
-
236
227
  describe 'filter conditions' do
237
- unless AjaxDatatablesRails.old_rails?
228
+ context 'date condition' do
238
229
  describe 'it can filter records with condition :date_range' do
239
- let(:datatable) { DatatableCondDate.new(view) }
230
+ let(:datatable) { DatatableCondDate.new(sample_params) }
240
231
 
241
- before(:each) do
232
+ before do
242
233
  create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'Doe', created_at: '01/01/2000')
243
234
  create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'Smith', created_at: '01/02/2000')
244
235
  end
245
236
 
246
237
  context 'when range is empty' do
247
- it 'should not filter records' do
238
+ it 'does not filter records' do
248
239
  datatable.params[:columns]['5'][:search][:value] = '-'
249
240
  expect(datatable.data.size).to eq 2
250
241
  item = datatable.data.first
@@ -253,21 +244,21 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
253
244
  end
254
245
 
255
246
  context 'when start date is filled' do
256
- it 'should filter records created after this date' do
247
+ it 'filters records created after this date' do
257
248
  datatable.params[:columns]['5'][:search][:value] = '31/12/1999-'
258
249
  expect(datatable.data.size).to eq 2
259
250
  end
260
251
  end
261
252
 
262
253
  context 'when end date is filled' do
263
- it 'should filter records created before this date' do
254
+ it 'filters records created before this date' do
264
255
  datatable.params[:columns]['5'][:search][:value] = '-31/12/1999'
265
256
  expect(datatable.data.size).to eq 0
266
257
  end
267
258
  end
268
259
 
269
260
  context 'when both date are filled' do
270
- it 'should filter records created between the range' do
261
+ it 'filters records created between the range' do
271
262
  datatable.params[:columns]['5'][:search][:value] = '01/12/1999-15/01/2000'
272
263
  expect(datatable.data.size).to eq 1
273
264
  end
@@ -275,7 +266,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
275
266
 
276
267
  context 'when another filter is active' do
277
268
  context 'when range is empty' do
278
- it 'should filter records' do
269
+ it 'filters records' do
279
270
  datatable.params[:columns]['0'][:search][:value] = 'doe'
280
271
  datatable.params[:columns]['5'][:search][:value] = '-'
281
272
  expect(datatable.data.size).to eq 1
@@ -285,7 +276,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
285
276
  end
286
277
 
287
278
  context 'when start date is filled' do
288
- it 'should filter records' do
279
+ it 'filters records' do
289
280
  datatable.params[:columns]['0'][:search][:value] = 'doe'
290
281
  datatable.params[:columns]['5'][:search][:value] = '01/12/1999-'
291
282
  expect(datatable.data.size).to eq 1
@@ -295,7 +286,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
295
286
  end
296
287
 
297
288
  context 'when end date is filled' do
298
- it 'should filter records' do
289
+ it 'filters records' do
299
290
  datatable.params[:columns]['0'][:search][:value] = 'doe'
300
291
  datatable.params[:columns]['5'][:search][:value] = '-15/01/2000'
301
292
  expect(datatable.data.size).to eq 1
@@ -305,7 +296,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
305
296
  end
306
297
 
307
298
  context 'when both date are filled' do
308
- it 'should filter records' do
299
+ it 'filters records' do
309
300
  datatable.params[:columns]['0'][:search][:value] = 'doe'
310
301
  datatable.params[:columns]['5'][:search][:value] = '01/12/1999-15/01/2000'
311
302
  expect(datatable.data.size).to eq 1
@@ -317,258 +308,310 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
317
308
  end
318
309
  end
319
310
 
320
- describe 'it can filter records with condition :start_with' do
321
- let(:datatable) { DatatableCondStartWith.new(view) }
322
-
323
- before(:each) do
324
- create(:user, first_name: 'John')
325
- create(:user, first_name: 'Mary')
326
- end
327
-
328
- it 'should filter records matching' do
329
- datatable.params[:columns]['2'][:search][:value] = 'Jo'
330
- expect(datatable.data.size).to eq 1
331
- item = datatable.data.first
332
- expect(item[:first_name]).to eq 'John'
311
+ context 'numeric condition' do
312
+ before do
313
+ create(:user, first_name: 'john', post_id: 1)
314
+ create(:user, first_name: 'mary', post_id: 2)
333
315
  end
334
- end
335
316
 
336
- describe 'it can filter records with condition :end_with' do
337
- let(:datatable) { DatatableCondEndWith.new(view) }
317
+ describe 'it can filter records with condition :eq' do
318
+ let(:datatable) { DatatableCondEq.new(sample_params) }
338
319
 
339
- before(:each) do
340
- create(:user, last_name: 'JOHN')
341
- create(:user, last_name: 'MARY')
342
- end
343
-
344
- if AjaxDatatablesRails.config.db_adapter == :oracleenhanced
345
- context 'when db_adapter is oracleenhanced' do
346
- it 'should filter records matching' do
347
- datatable.params[:columns]['3'][:search][:value] = 'RY'
348
- expect(datatable.data.size).to eq 1
349
- item = datatable.data.first
350
- expect(item[:last_name]).to eq 'MARY'
351
- end
352
- end
353
- else
354
- it 'should filter records matching' do
355
- datatable.params[:columns]['3'][:search][:value] = 'ry'
320
+ it 'filters records matching' do
321
+ datatable.params[:columns]['4'][:search][:value] = 1
356
322
  expect(datatable.data.size).to eq 1
357
323
  item = datatable.data.first
358
- expect(item[:last_name]).to eq 'MARY'
324
+ expect(item[:first_name]).to eq 'john'
359
325
  end
360
326
  end
361
- end
362
327
 
363
- describe 'it can filter records with condition :like' do
364
- let(:datatable) { DatatableCondLike.new(view) }
328
+ describe 'it can filter records with condition :not_eq' do
329
+ let(:datatable) { DatatableCondNotEq.new(sample_params) }
365
330
 
366
- before(:each) do
367
- create(:user, email: 'john@foo.com')
368
- create(:user, email: 'mary@bar.com')
331
+ it 'filters records matching' do
332
+ datatable.params[:columns]['4'][:search][:value] = 1
333
+ expect(datatable.data.size).to eq 1
334
+ item = datatable.data.first
335
+ expect(item[:first_name]).to eq 'mary'
336
+ end
369
337
  end
370
338
 
371
- it 'should filter records matching' do
372
- datatable.params[:columns]['1'][:search][:value] = 'foo'
373
- expect(datatable.data.size).to eq 1
374
- item = datatable.data.first
375
- expect(item[:email]).to eq 'john@foo.com'
339
+ describe 'it can filter records with condition :lt' do
340
+ let(:datatable) { DatatableCondLt.new(sample_params) }
341
+
342
+ it 'filters records matching' do
343
+ datatable.params[:columns]['4'][:search][:value] = 2
344
+ expect(datatable.data.size).to eq 1
345
+ item = datatable.data.first
346
+ expect(item[:first_name]).to eq 'john'
347
+ end
376
348
  end
377
- end
378
349
 
379
- describe 'it can filter records with condition :string_eq' do
380
- let(:datatable) { DatatableCondStringEq.new(view) }
350
+ describe 'it can filter records with condition :gt' do
351
+ let(:datatable) { DatatableCondGt.new(sample_params) }
381
352
 
382
- before(:each) do
383
- create(:user, email: 'john@foo.com')
384
- create(:user, email: 'mary@bar.com')
353
+ it 'filters records matching' do
354
+ datatable.params[:columns]['4'][:search][:value] = 1
355
+ expect(datatable.data.size).to eq 1
356
+ item = datatable.data.first
357
+ expect(item[:first_name]).to eq 'mary'
358
+ end
385
359
  end
386
360
 
387
- it 'should filter records matching' do
388
- datatable.params[:columns]['1'][:search][:value] = 'john@foo.com'
389
- expect(datatable.data.size).to eq 1
390
- item = datatable.data.first
391
- expect(item[:email]).to eq 'john@foo.com'
361
+ describe 'it can filter records with condition :lteq' do
362
+ let(:datatable) { DatatableCondLteq.new(sample_params) }
363
+
364
+ it 'filters records matching' do
365
+ datatable.params[:columns]['4'][:search][:value] = 2
366
+ expect(datatable.data.size).to eq 2
367
+ end
392
368
  end
393
- end
394
369
 
395
- describe 'it can filter records with condition :null_value' do
396
- let(:datatable) { DatatableCondNullValue.new(view) }
370
+ describe 'it can filter records with condition :gteq' do
371
+ let(:datatable) { DatatableCondGteq.new(sample_params) }
397
372
 
398
- before(:each) do
399
- create(:user, first_name: 'john', email: 'foo@bar.com')
400
- create(:user, first_name: 'mary', email: nil)
373
+ it 'filters records matching' do
374
+ datatable.params[:columns]['4'][:search][:value] = 1
375
+ expect(datatable.data.size).to eq 2
376
+ end
401
377
  end
402
378
 
403
- context 'when condition is NULL' do
404
- it 'should filter records matching' do
405
- datatable.params[:columns]['1'][:search][:value] = 'NULL'
379
+ describe 'it can filter records with condition :in' do
380
+ let(:datatable) { DatatableCondIn.new(sample_params) }
381
+
382
+ it 'filters records matching' do
383
+ datatable.params[:columns]['4'][:search][:value] = [1]
406
384
  expect(datatable.data.size).to eq 1
407
385
  item = datatable.data.first
408
- expect(item[:first_name]).to eq 'mary'
386
+ expect(item[:first_name]).to eq 'john'
409
387
  end
410
388
  end
411
389
 
412
- context 'when condition is !NULL' do
413
- it 'should filter records matching' do
414
- datatable.params[:columns]['1'][:search][:value] = '!NULL'
415
- expect(datatable.data.size).to eq 1
390
+ describe 'it can filter records with condition :in with regex' do
391
+ let(:datatable) { DatatableCondInWithRegex.new(sample_params) }
392
+
393
+ it 'filters records matching' do
394
+ datatable.params[:columns]['4'][:search][:value] = '1|2'
395
+ datatable.params[:order]['0'] = { column: '4', dir: 'asc' }
396
+ expect(datatable.data.size).to eq 2
416
397
  item = datatable.data.first
417
398
  expect(item[:first_name]).to eq 'john'
418
399
  end
419
400
  end
420
- end
421
401
 
422
- describe 'it can filter records with condition :eq' do
423
- let(:datatable) { DatatableCondEq.new(view) }
402
+ describe 'Integer overflows' do
403
+ let(:datatable) { DatatableCondEq.new(sample_params) }
404
+ let(:largest_postgresql_integer_value) { 2_147_483_647 }
405
+ let(:smallest_postgresql_integer_value) { -2_147_483_648 }
424
406
 
425
- before(:each) do
426
- create(:user, first_name: 'john', post_id: 1)
427
- create(:user, first_name: 'mary', post_id: 2)
428
- end
407
+ before do
408
+ create(:user, first_name: 'john', post_id: 1)
409
+ create(:user, first_name: 'mary', post_id: 2)
410
+ create(:user, first_name: 'phil', post_id: largest_postgresql_integer_value)
411
+ end
429
412
 
430
- it 'should filter records matching' do
431
- datatable.params[:columns]['4'][:search][:value] = 1
432
- expect(datatable.data.size).to eq 1
433
- item = datatable.data.first
434
- expect(item[:first_name]).to eq 'john'
413
+ it 'Returns an empty result if input value is too large' do
414
+ datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value + 1
415
+ expect(datatable.data.size).to eq 0
416
+ end
417
+
418
+ it 'Returns an empty result if input value is too small' do
419
+ datatable.params[:columns]['4'][:search][:value] = smallest_postgresql_integer_value - 1
420
+ expect(datatable.data.size).to eq 0
421
+ end
422
+
423
+ it 'returns the matching user' do
424
+ datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value
425
+ expect(datatable.data.size).to eq 1
426
+ end
435
427
  end
436
428
  end
437
429
 
438
- describe 'it can filter records with condition :not_eq' do
439
- let(:datatable) { DatatableCondNotEq.new(view) }
430
+ context 'proc condition' do
431
+ describe 'it can filter records with lambda/proc condition' do
432
+ let(:datatable) { DatatableCondProc.new(sample_params) }
440
433
 
441
- before(:each) do
442
- create(:user, first_name: 'john', post_id: 1)
443
- create(:user, first_name: 'mary', post_id: 2)
444
- end
434
+ before do
435
+ create(:user, username: 'johndoe', email: 'johndoe@example.com')
436
+ create(:user, username: 'johndie', email: 'johndie@example.com')
437
+ create(:user, username: 'msmith', email: 'mary.smith@example.com')
438
+ end
445
439
 
446
- it 'should filter records matching' do
447
- datatable.params[:columns]['4'][:search][:value] = 1
448
- expect(datatable.data.size).to eq 1
449
- item = datatable.data.first
450
- expect(item[:first_name]).to eq 'mary'
440
+ it 'filters records matching' do
441
+ datatable.params[:columns]['0'][:search][:value] = 'john'
442
+ expect(datatable.data.size).to eq 2
443
+ item = datatable.data.first
444
+ expect(item[:username]).to eq 'johndie'
445
+ end
451
446
  end
452
447
  end
453
448
 
454
- describe 'it can filter records with condition :lt' do
455
- let(:datatable) { DatatableCondLt.new(view) }
449
+ context 'string condition' do
450
+ describe 'it can filter records with condition :start_with' do
451
+ let(:datatable) { DatatableCondStartWith.new(sample_params) }
456
452
 
457
- before(:each) do
458
- create(:user, first_name: 'john', post_id: 1)
459
- create(:user, first_name: 'mary', post_id: 2)
460
- end
453
+ before do
454
+ create(:user, first_name: 'John')
455
+ create(:user, first_name: 'Mary')
456
+ end
461
457
 
462
- it 'should filter records matching' do
463
- datatable.params[:columns]['4'][:search][:value] = 2
464
- expect(datatable.data.size).to eq 1
465
- item = datatable.data.first
466
- expect(item[:first_name]).to eq 'john'
458
+ it 'filters records matching' do
459
+ datatable.params[:columns]['2'][:search][:value] = 'Jo'
460
+ expect(datatable.data.size).to eq 1
461
+ item = datatable.data.first
462
+ expect(item[:first_name]).to eq 'John'
463
+ end
467
464
  end
468
- end
469
465
 
470
- describe 'it can filter records with condition :gt' do
471
- let(:datatable) { DatatableCondGt.new(view) }
466
+ describe 'it can filter records with condition :end_with' do
467
+ let(:datatable) { DatatableCondEndWith.new(sample_params) }
472
468
 
473
- before(:each) do
474
- create(:user, first_name: 'john', post_id: 1)
475
- create(:user, first_name: 'mary', post_id: 2)
476
- end
469
+ before do
470
+ create(:user, last_name: 'JOHN')
471
+ create(:user, last_name: 'MARY')
472
+ end
477
473
 
478
- it 'should filter records matching' do
479
- datatable.params[:columns]['4'][:search][:value] = 1
480
- expect(datatable.data.size).to eq 1
481
- item = datatable.data.first
482
- expect(item[:first_name]).to eq 'mary'
474
+ if ENV['DB_ADAPTER'] == 'oracle_enhanced'
475
+ context 'when db_adapter is oracleenhanced' do
476
+ it 'filters records matching' do
477
+ datatable.params[:columns]['3'][:search][:value] = 'RY'
478
+ expect(datatable.data.size).to eq 1
479
+ item = datatable.data.first
480
+ expect(item[:last_name]).to eq 'MARY'
481
+ end
482
+ end
483
+ else
484
+ it 'filters records matching' do
485
+ datatable.params[:columns]['3'][:search][:value] = 'ry'
486
+ expect(datatable.data.size).to eq 1
487
+ item = datatable.data.first
488
+ expect(item[:last_name]).to eq 'MARY'
489
+ end
490
+ end
483
491
  end
484
- end
485
492
 
486
- describe 'it can filter records with condition :lteq' do
487
- let(:datatable) { DatatableCondLteq.new(view) }
493
+ describe 'it can filter records with condition :like' do
494
+ let(:datatable) { DatatableCondLike.new(sample_params) }
488
495
 
489
- before(:each) do
490
- create(:user, first_name: 'john', post_id: 1)
491
- create(:user, first_name: 'mary', post_id: 2)
492
- end
496
+ before do
497
+ create(:user, email: 'john@foo.com')
498
+ create(:user, email: 'mary@bar.com')
499
+ end
493
500
 
494
- it 'should filter records matching' do
495
- datatable.params[:columns]['4'][:search][:value] = 2
496
- expect(datatable.data.size).to eq 2
501
+ it 'filters records matching' do
502
+ datatable.params[:columns]['1'][:search][:value] = 'foo'
503
+ expect(datatable.data.size).to eq 1
504
+ item = datatable.data.first
505
+ expect(item[:email]).to eq 'john@foo.com'
506
+ end
497
507
  end
498
- end
499
508
 
500
- describe 'it can filter records with condition :gteq' do
501
- let(:datatable) { DatatableCondGteq.new(view) }
509
+ describe 'it can filter records with condition :string_eq' do
510
+ let(:datatable) { DatatableCondStringEq.new(sample_params) }
502
511
 
503
- before(:each) do
504
- create(:user, first_name: 'john', post_id: 1)
505
- create(:user, first_name: 'mary', post_id: 2)
506
- end
512
+ before do
513
+ create(:user, email: 'john@foo.com')
514
+ create(:user, email: 'mary@bar.com')
515
+ end
507
516
 
508
- it 'should filter records matching' do
509
- datatable.params[:columns]['4'][:search][:value] = 1
510
- expect(datatable.data.size).to eq 2
517
+ it 'filters records matching' do
518
+ datatable.params[:columns]['1'][:search][:value] = 'john@foo.com'
519
+ expect(datatable.data.size).to eq 1
520
+ item = datatable.data.first
521
+ expect(item[:email]).to eq 'john@foo.com'
522
+ end
511
523
  end
512
- end
513
524
 
514
- describe 'it can filter records with condition :in' do
515
- let(:datatable) { DatatableCondIn.new(view) }
525
+ describe 'it can filter records with condition :string_in' do
526
+ let(:datatable) { DatatableCondStringIn.new(sample_params) }
516
527
 
517
- before(:each) do
518
- create(:user, first_name: 'john', post_id: 1)
519
- create(:user, first_name: 'mary', post_id: 2)
520
- end
528
+ before do
529
+ create(:user, email: 'john@foo.com')
530
+ create(:user, email: 'mary@bar.com')
531
+ create(:user, email: 'henry@baz.com')
532
+ end
521
533
 
522
- it 'should filter records matching' do
523
- datatable.params[:columns]['4'][:search][:value] = [1]
524
- expect(datatable.data.size).to eq 1
525
- item = datatable.data.first
526
- expect(item[:first_name]).to eq 'john'
527
- end
528
- end
534
+ it 'filters records matching' do
535
+ datatable.params[:columns]['1'][:search][:value] = 'john@foo.com'
536
+ expect(datatable.data.size).to eq 1
537
+ item = datatable.data.first
538
+ expect(item[:email]).to eq 'john@foo.com'
539
+ end
529
540
 
530
- describe 'it can filter records with condition :in with regex' do
531
- let(:datatable) { DatatableCondInWithRegex.new(view) }
541
+ it 'filters records matching with multiple' do
542
+ datatable.params[:columns]['1'][:search][:value] = 'john@foo.com|henry@baz.com'
543
+ expect(datatable.data.size).to eq 2
544
+ items = datatable.data.sort_by { |h| h[:email] }
545
+ item_first = items.first
546
+ item_last = items.last
547
+ expect(item_first[:email]).to eq 'henry@baz.com'
548
+ expect(item_last[:email]).to eq 'john@foo.com'
549
+ end
532
550
 
533
- before(:each) do
534
- create(:user, first_name: 'john', post_id: 1)
535
- create(:user, first_name: 'mary', post_id: 2)
551
+ it 'filters records matching with multiple contains not found' do
552
+ datatable.params[:columns]['1'][:search][:value] = 'john@foo.com|henry_not@baz.com'
553
+ expect(datatable.data.size).to eq 1
554
+ item = datatable.data.first
555
+ expect(item[:email]).to eq 'john@foo.com'
556
+ end
536
557
  end
537
558
 
538
- it 'should filter records matching' do
539
- datatable.params[:columns]['4'][:search][:value] = '1|2'
540
- datatable.params[:order]['0'] = { column: '4', dir: 'asc' }
541
- expect(datatable.data.size).to eq 2
542
- item = datatable.data.first
543
- expect(item[:first_name]).to eq 'john'
559
+ describe 'it can filter records with condition :null_value' do
560
+ let(:datatable) { DatatableCondNullValue.new(sample_params) }
561
+
562
+ before do
563
+ create(:user, first_name: 'john', email: 'foo@bar.com')
564
+ create(:user, first_name: 'mary', email: nil)
565
+ end
566
+
567
+ context 'when condition is NULL' do
568
+ it 'filters records matching' do
569
+ datatable.params[:columns]['1'][:search][:value] = 'NULL'
570
+ expect(datatable.data.size).to eq 1
571
+ item = datatable.data.first
572
+ expect(item[:first_name]).to eq 'mary'
573
+ end
574
+ end
575
+
576
+ context 'when condition is !NULL' do
577
+ it 'filters records matching' do
578
+ datatable.params[:columns]['1'][:search][:value] = '!NULL'
579
+ expect(datatable.data.size).to eq 1
580
+ item = datatable.data.first
581
+ expect(item[:first_name]).to eq 'john'
582
+ end
583
+ end
544
584
  end
545
585
  end
546
586
 
547
- describe 'Integer overflows' do
548
- let(:datatable) { DatatableCondEq.new(view) }
549
- let(:largest_postgresql_integer_value) { 2147483647 }
550
- let(:smallest_postgresql_integer_value) { -2147483648 }
587
+ context 'unknown condition' do
588
+ let(:datatable) { DatatableCondUnknown.new(sample_params) }
551
589
 
552
- before(:each) do
553
- create(:user, first_name: 'john', post_id: 1)
554
- create(:user, first_name: 'mary', post_id: 2)
555
- create(:user, first_name: 'phil', post_id: largest_postgresql_integer_value)
590
+ before do
591
+ datatable.params[:search] = { value: 'john doe', regex: 'false' }
556
592
  end
557
593
 
558
- it 'Returns an empty result if input value is too large' do
559
- datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value + 1
560
- expect(datatable.data.size).to eq 0
594
+ it 'raises error' do
595
+ expect {
596
+ datatable.data.size
597
+ }.to raise_error(AjaxDatatablesRails::Error::InvalidSearchCondition).with_message('foo')
561
598
  end
599
+ end
600
+ end
562
601
 
563
- it 'Returns an empty result if input value is too small' do
564
- datatable.params[:columns]['4'][:search][:value] = smallest_postgresql_integer_value - 1
565
- expect(datatable.data.size).to eq 0
566
- end
602
+ describe 'formatter option' do
603
+ let(:datatable) { DatatableWithFormater.new(sample_params) }
567
604
 
568
- it 'returns the matching user' do
569
- datatable.params[:columns]['4'][:search][:value] = largest_postgresql_integer_value
570
- expect(datatable.data.size).to eq 1
571
- end
605
+ before do
606
+ create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'DOE')
607
+ create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'SMITH')
608
+ datatable.params[:columns]['3'][:search][:value] = 'doe'
609
+ end
610
+
611
+ it 'can transform search value before asking the database' do
612
+ expect(datatable.data.size).to eq 1
613
+ item = datatable.data.first
614
+ expect(item[:last_name]).to eq 'DOE'
572
615
  end
573
616
  end
574
617
  end