1 | (function(TableFilter) {
|
2 | var id = function (id) { return document.getElementById(id); };
|
3 |
|
4 |
|
5 | var tf = new TableFilter('demo', {
|
6 | base_path: '../dist/tablefilter/',
|
7 | col_types: [
|
8 | null, null, null,
|
9 | { type: 'formatted-number', decimal: ',', thousands: ','},
|
10 | 'formatted-number', null,
|
11 | { type: 'date', locale: 'fr', },
|
12 | { type: 'date', locale: 'en', format: '{dd}-{MM}-{yyyy|yy}' },
|
13 | { type: 'date', locale: 'en', format: ['{dd}-{months}-{yyyy|yy}'] },
|
14 | 'IpAddress',
|
15 | {
|
16 | type: 'date', locale: 'en',
|
17 | format: ['{yyyy|yy}-{MM}-{dd} {HH}:{mm}:{ss}']
|
18 | }
|
19 | ]
|
20 | });
|
21 | tf.init();
|
22 |
|
23 | module('Sanity checks');
|
24 | test('Data types', function() {
|
25 | deepEqual(tf instanceof TableFilter, true, 'TableFilter instanciated');
|
26 | deepEqual(
|
27 | tf.hasType(3, ['formatted-number']) &&
|
28 | tf.hasType(4, ['formatted-number']),
|
29 | true, 'Has number column types'
|
30 | );
|
31 | deepEqual(
|
32 | tf.hasType(6, ['date']) &&
|
33 | tf.hasType(7, ['date']) &&
|
34 | tf.hasType(8, ['date']),
|
35 | true, 'Has date column types'
|
36 | );
|
37 | });
|
38 |
|
39 | module('Data types filtering');
|
40 | test('Can filter a column with a string', function() {
|
41 |
|
42 | tf.setFilterValue(0, 'carl');
|
43 | tf.filter();
|
44 |
|
45 |
|
46 | deepEqual(tf.getValidRows(), [14, 18], 'Expected rows');
|
47 |
|
48 | });
|
49 |
|
50 | test('Can filter a EU formatted number', function() {
|
51 |
|
52 | tf.clearFilters();
|
53 |
|
54 |
|
55 | tf.setFilterValue(3, '1.836,09');
|
56 | tf.filter();
|
57 |
|
58 |
|
59 | deepEqual(tf.getValidRows(), [6], 'Expected rows');
|
60 | });
|
61 |
|
62 | test('Can filter a EU formatted number column with a number', function() {
|
63 |
|
64 | tf.clearFilters();
|
65 |
|
66 |
|
67 | tf.setFilterValue(3, 3876);
|
68 | tf.filter();
|
69 |
|
70 |
|
71 | deepEqual(tf.getValidRows(), [14], 'Expected rows');
|
72 | });
|
73 |
|
74 | test('Can filter a EU formatted number column with a number without ' +
|
75 | 'thousands separator', function() {
|
76 |
|
77 | tf.clearFilters();
|
78 |
|
79 |
|
80 | tf.setFilterValue(3, '1393,52');
|
81 | tf.filter();
|
82 |
|
83 |
|
84 | deepEqual(tf.getValidRows(), [13], 'Expected rows');
|
85 | });
|
86 |
|
87 | test('Can filter a EU formatted number column with a number without ' +
|
88 | 'decimals', function() {
|
89 |
|
90 | tf.clearFilters();
|
91 |
|
92 |
|
93 | tf.setFilterValue(3, '2.805');
|
94 | tf.filter();
|
95 |
|
96 |
|
97 | deepEqual(tf.getValidRows(), [7], 'Expected rows');
|
98 | });
|
99 |
|
100 | test('Can filter a formatted number', function() {
|
101 |
|
102 | tf.clearFilters();
|
103 |
|
104 |
|
105 | tf.setFilterValue(4, '1,836.09');
|
106 | tf.filter();
|
107 |
|
108 |
|
109 | deepEqual(tf.getValidRows(), [6], 'Expected rows');
|
110 | });
|
111 |
|
112 | test('Can filter a number', function() {
|
113 |
|
114 | tf.clearFilters();
|
115 |
|
116 |
|
117 | tf.setFilterValue(4, 1836.09);
|
118 | tf.filter();
|
119 |
|
120 |
|
121 | deepEqual(tf.getValidRows(), [6], 'Expected rows');
|
122 | });
|
123 |
|
124 | test('Can filter a formatted number column with a number', function() {
|
125 |
|
126 | tf.clearFilters();
|
127 |
|
128 |
|
129 | tf.setFilterValue(4, 3876);
|
130 | tf.filter();
|
131 |
|
132 |
|
133 | deepEqual(tf.getValidRows(), [14], 'Expected rows');
|
134 | });
|
135 |
|
136 | test('Can filter a formatted number column with a number without ' +
|
137 | 'thousands separator', function() {
|
138 |
|
139 | tf.clearFilters();
|
140 |
|
141 |
|
142 | tf.setFilterValue(4, '1393.52');
|
143 | tf.filter();
|
144 |
|
145 |
|
146 | deepEqual(tf.getValidRows(), [13], 'Expected rows');
|
147 | });
|
148 |
|
149 | test('Can filter a formatted number column with a number without ' +
|
150 | 'decimals', function() {
|
151 |
|
152 | tf.clearFilters();
|
153 |
|
154 |
|
155 | tf.setFilterValue(4, '2,805');
|
156 | tf.filter();
|
157 |
|
158 |
|
159 | deepEqual(tf.getValidRows(), [7], 'Expected rows');
|
160 | });
|
161 |
|
162 | test('Can filter a EU formatted date column', function() {
|
163 |
|
164 | tf.clearFilters();
|
165 |
|
166 |
|
167 | tf.setFilterValue(6, '14/7/1994');
|
168 | tf.filter();
|
169 |
|
170 |
|
171 | deepEqual(tf.getValidRows(), [16], 'Expected rows');
|
172 | });
|
173 |
|
174 | test('Can filter a EU formatted date column with different date separator',
|
175 | function() {
|
176 |
|
177 | tf.clearFilters();
|
178 |
|
179 |
|
180 | tf.setFilterValue(6, '20-10-97');
|
181 | tf.filter();
|
182 |
|
183 |
|
184 | deepEqual(tf.getValidRows(), [17], 'Expected rows');
|
185 | });
|
186 |
|
187 | test('Can filter a formatted date column', function() {
|
188 |
|
189 | tf.clearFilters();
|
190 |
|
191 |
|
192 | tf.setFilterValue(7, '7/14/1994');
|
193 | tf.filter();
|
194 |
|
195 |
|
196 | deepEqual(tf.getValidRows(), [16], 'Expected rows');
|
197 | });
|
198 |
|
199 | test('Can filter a formatted date column with different date separator',
|
200 | function() {
|
201 |
|
202 | tf.clearFilters();
|
203 |
|
204 |
|
205 | tf.setFilterValue(7, '10-20-97');
|
206 | tf.filter();
|
207 |
|
208 |
|
209 | deepEqual(tf.getValidRows(), [17], 'Expected rows');
|
210 | });
|
211 |
|
212 | test('Can filter a dd-MMM-yyy formatted date column', function() {
|
213 |
|
214 | tf.clearFilters();
|
215 |
|
216 |
|
217 | tf.setFilterValue(8, '3-Jul-2002');
|
218 | tf.filter();
|
219 |
|
220 |
|
221 | deepEqual(tf.getValidRows(), [8], 'Expected rows');
|
222 | });
|
223 |
|
224 | test('Can filter a dd-MMM-yyy formatted date column with different date ' +
|
225 | 'separator', function() {
|
226 |
|
227 | tf.clearFilters();
|
228 |
|
229 |
|
230 | tf.setFilterValue(8, '25.Mar.2000');
|
231 | tf.filter();
|
232 |
|
233 |
|
234 | deepEqual(tf.getValidRows(), [4], 'Expected rows');
|
235 | });
|
236 |
|
237 | test('Can filter an IP address column', function() {
|
238 |
|
239 | tf.clearFilters();
|
240 |
|
241 |
|
242 | tf.setFilterValue(9, '219.115.156.145');
|
243 | tf.filter();
|
244 |
|
245 |
|
246 | deepEqual(tf.getValidRows(), [8], 'Expected rows');
|
247 | });
|
248 |
|
249 | test('Can filter an IP address column with a truncated IP address',
|
250 | function() {
|
251 |
|
252 | tf.clearFilters();
|
253 |
|
254 |
|
255 | tf.setFilterValue(9, '219.115.15');
|
256 | tf.filter();
|
257 |
|
258 |
|
259 | deepEqual(tf.getValidRows(), [4, 8, 14], 'Expected rows');
|
260 | });
|
261 |
|
262 | test('Can filter datetime format', function() {
|
263 |
|
264 | tf.clearFilters();
|
265 |
|
266 |
|
267 | tf.setFilterValue(10, '2006-06-03 11:59:48');
|
268 | tf.filter();
|
269 |
|
270 |
|
271 | deepEqual(tf.getValidRows(), [8], 'Expected rows');
|
272 | });
|
273 |
|
274 | test('Can filter datetime format with operator', function() {
|
275 |
|
276 | tf.clearFilters();
|
277 |
|
278 |
|
279 | tf.setFilterValue(10, '>2006-06-03 11:59:48');
|
280 | tf.filter();
|
281 |
|
282 |
|
283 | deepEqual(tf.getValidRows().length, 7, 'Expected rows');
|
284 | });
|
285 |
|
286 | module('Locale helpers');
|
287 | test('Can get decimal separator for given column from config', function() {
|
288 |
|
289 | var result = tf.getDecimal(3);
|
290 |
|
291 |
|
292 | deepEqual(result, ',', 'Decimal separator for given column');
|
293 | });
|
294 |
|
295 | test('Can get decimal separator for given column from global setting',
|
296 | function() {
|
297 |
|
298 | var result = tf.getDecimal(1);
|
299 |
|
300 |
|
301 | deepEqual(result, '.', 'Decimal separator for given column');
|
302 | });
|
303 |
|
304 | module('Data types filters options sorting');
|
305 | test('Can sort date types', function () {
|
306 |
|
307 | tf.clearFilters();
|
308 | tf.destroy();
|
309 | tf = new TableFilter('demo', {
|
310 | base_path: '../dist/tablefilter/',
|
311 | col_6: 'checklist',
|
312 | col_7: 'multiple',
|
313 | col_8: 'checklist',
|
314 | col_10: 'select',
|
315 | col_types: [
|
316 | null, null, null,
|
317 | {type: 'formatted-number', decimal: ',', thousands: ','},
|
318 | 'formatted-number', null,
|
319 | {type: 'date', locale: 'fr',},
|
320 | {type: 'date', locale: 'en', format: '{dd}-{MM}-{yyyy|yy}'},
|
321 | {
|
322 | type: 'date', locale: 'en',
|
323 | format: ['{dd}-{months}-{yyyy|yy}']
|
324 | },
|
325 | 'IpAddress',
|
326 | {
|
327 | type: 'date', locale: 'en',
|
328 | format: ['{yyyy|yy}-{MM}-{dd} {HH}:{mm}:{ss}']
|
329 | }
|
330 | ],
|
331 | sort_filter_options_asc: [6, 7],
|
332 | sort_filter_options_desc: [8, 10]
|
333 | });
|
334 |
|
335 |
|
336 | tf.init();
|
337 |
|
338 | var flt6 = id(tf.fltIds[6]);
|
339 | var flt7 = id(tf.fltIds[7]);
|
340 | var flt8 = id(tf.fltIds[8]);
|
341 | var flt10 = id(tf.fltIds[10]);
|
342 |
|
343 |
|
344 | deepEqual(
|
345 | flt6.getElementsByTagName('li')[1].firstChild.firstChild.value,
|
346 | '19/1/1984',
|
347 | 'First option value for column 6'
|
348 | );
|
349 | deepEqual(
|
350 | flt6.getElementsByTagName('li')[20].firstChild.firstChild.value,
|
351 | '3/7/2002',
|
352 | 'Last option value for column 6'
|
353 | );
|
354 | deepEqual(
|
355 | flt7.options[1].value,
|
356 | '1/19/1984',
|
357 | 'First option value for column 7'
|
358 | );
|
359 | deepEqual(
|
360 | flt7.options[20].value,
|
361 | '7/3/2002',
|
362 | 'Last option value for column 7'
|
363 | );
|
364 | deepEqual(
|
365 | flt8.getElementsByTagName('li')[1].firstChild.firstChild.value,
|
366 | '3-Jul-2002',
|
367 | 'First option value for column 8'
|
368 | );
|
369 | deepEqual(
|
370 | flt8.getElementsByTagName('li')[20].firstChild.firstChild.value,
|
371 | '19-Jan-1984',
|
372 | 'Last option value for column 8'
|
373 | );
|
374 | deepEqual(
|
375 | flt10.options[1].value,
|
376 | '03-11-21 12:02:04',
|
377 | 'First option value for column 10'
|
378 | );
|
379 | deepEqual(
|
380 | flt10.options[19].value,
|
381 | '1899-11-27 02:02:04',
|
382 | 'Last option value for column 10'
|
383 | );
|
384 | });
|
385 |
|
386 | module('Tear-down');
|
387 | test('can destroy TableFilter DOM elements', function() {
|
388 | tf.destroy();
|
389 | deepEqual(tf.isInitialized(), false, 'Filters removed');
|
390 | });
|
391 |
|
392 | })(TableFilter);
|