1 |
|
2 | var tf = new TableFilter('demo', {
|
3 | base_path: '../dist/tablefilter/',
|
4 | alternate_rows: true
|
5 | });
|
6 | tf.init();
|
7 | var tbl = tf.dom();
|
8 | var altRows = tf.feature('alternateRows');
|
9 |
|
10 | module('Sanity checks');
|
11 | test('AlternateRows component', function() {
|
12 | deepEqual(typeof altRows, 'object', 'AlternateRows instanciated');
|
13 | deepEqual(altRows.evenCss, 'even', 'Expected even css class');
|
14 | deepEqual(altRows.oddCss, 'odd', 'Expected odd css class');
|
15 | });
|
16 |
|
17 | module('Feature interface');
|
18 | test('Properties', function() {
|
19 | deepEqual(
|
20 | altRows.tf instanceof TableFilter, true, 'TableFilter instance');
|
21 | deepEqual(altRows.feature, 'alternateRows', 'Feature name');
|
22 | deepEqual(altRows.enabled, true, 'Feature enabled');
|
23 | deepEqual(altRows.initialized, true, 'Feature enabled');
|
24 | deepEqual(typeof altRows.emitter, 'object', 'Feature has emitter instance');
|
25 | deepEqual(typeof altRows.config, 'object', 'TF configuration object');
|
26 | deepEqual(typeof altRows.init, 'function', 'Feature init method');
|
27 | deepEqual(typeof altRows.destroy, 'function', 'Feature destroy method');
|
28 | deepEqual(typeof altRows.reset, 'function', 'Feature reset method');
|
29 | deepEqual(typeof altRows.enable, 'function', 'Feature enable method');
|
30 | deepEqual(typeof altRows.disable, 'function', 'Feature enable method');
|
31 | deepEqual(
|
32 | typeof altRows.isEnabled, 'function', 'Feature enable method');
|
33 | });
|
34 | test('Can destroy', function() {
|
35 | altRows.destroy();
|
36 | deepEqual(altRows.initialized, false, 'not initialised');
|
37 | deepEqual(
|
38 | altRows.emitter.events['row-processed'].length,
|
39 | 0,
|
40 | '`row-processed` event handler removed'
|
41 | );
|
42 | deepEqual(
|
43 | altRows.emitter.events['row-paged'].length,
|
44 | 0,
|
45 | '`row-paged` event handler removed'
|
46 | );
|
47 | deepEqual(
|
48 | altRows.emitter.events['column-sorted'].length,
|
49 | 0,
|
50 | '`column-sorted` event handler removed'
|
51 | );
|
52 | deepEqual(
|
53 | altRows.emitter.events['rows-changed'].length,
|
54 | 0,
|
55 | '`rows-changed` event handler removed'
|
56 | );
|
57 | });
|
58 | test('Can reset', function() {
|
59 | altRows.reset();
|
60 | deepEqual(altRows.enabled, true, 'enabled');
|
61 | });
|
62 | test('Can disable', function() {
|
63 | altRows.disable();
|
64 | deepEqual(altRows.enabled, false, 'disabled');
|
65 | });
|
66 | test('Can enable', function() {
|
67 | altRows.enable();
|
68 | deepEqual(altRows.enabled, true, 'enabled');
|
69 | });
|
70 | test('Can init', function() {
|
71 | altRows.destroy();
|
72 | altRows.enable();
|
73 | altRows.init();
|
74 | deepEqual(altRows.enabled, true, 'enabled');
|
75 | });
|
76 | test('Can check is enabled', function() {
|
77 | altRows.isEnabled();
|
78 | deepEqual(altRows.enabled, true, 'enabled');
|
79 | });
|
80 |
|
81 | module('Actions');
|
82 | test('Filter column', function() {
|
83 | tf.setFilterValue(2, '>1400');
|
84 | tf.filter();
|
85 |
|
86 | deepEqual(tbl.querySelectorAll('tr.odd').length, 2, 'Odd bgs removed');
|
87 | deepEqual(tbl.querySelectorAll('tr.even').length, 2, 'Even bg removed');
|
88 | });
|
89 |
|
90 | test('Clear filters', function() {
|
91 | tf.clearFilters();
|
92 | tf.filter();
|
93 |
|
94 | deepEqual(tbl.querySelectorAll('tr.odd').length, 4, 'Odd bgs removed');
|
95 | deepEqual(tbl.querySelectorAll('tr.even').length, 3, 'Even bg removed');
|
96 | });
|
97 |
|
98 | test('Set background on a row', function() {
|
99 | altRows.setRowBg(4);
|
100 | deepEqual(tbl.rows[4].className, 'odd', 'Bg set on expected row');
|
101 | });
|
102 |
|
103 | test('Remove background on a row', function() {
|
104 | altRows.removeRowBg(4);
|
105 | deepEqual(tbl.rows[4].querySelectorAll('.odd').length,
|
106 | 0, 'Bg set on expected row');
|
107 | });
|
108 |
|
109 | test('Cannot init if initialised', function() {
|
110 |
|
111 | var processAll = altRows.processAll;
|
112 | var hit = 0;
|
113 | altRows.processAll = function() { hit++; };
|
114 | altRows.initialized = true;
|
115 |
|
116 |
|
117 | altRows.init();
|
118 |
|
119 |
|
120 | deepEqual(hit, 0, 'processAll not called');
|
121 |
|
122 | altRows.processAll = processAll;
|
123 | });
|
124 |
|
125 | test('Cannot processAll if not enabled', function() {
|
126 |
|
127 | var setRowBg = altRows.setRowBg;
|
128 | var hit = 0;
|
129 | altRows.setRowBg = function() { hit++; };
|
130 | altRows.enabled = false;
|
131 |
|
132 |
|
133 | altRows.processAll();
|
134 |
|
135 |
|
136 | deepEqual(hit, 0, 'setRowBg not called');
|
137 |
|
138 | altRows.setRowBg = setRowBg;
|
139 | });
|
140 |
|
141 | test('Cannot setRowBg if not enabled', function() {
|
142 |
|
143 | var removeRowBg = altRows.removeRowBg;
|
144 | var hit = 0;
|
145 | altRows.removeRowBg = function() { hit++; };
|
146 | altRows.enabled = false;
|
147 |
|
148 |
|
149 | altRows.setRowBg(3, 5);
|
150 |
|
151 |
|
152 | deepEqual(hit, 0, 'removeRowBg not called');
|
153 |
|
154 | altRows.removeRowBg = removeRowBg;
|
155 | });
|
156 |
|
157 | test('Cannot removeRowBg if row index is NaN', function() {
|
158 |
|
159 | tf.clearFilters();
|
160 | tf.filter();
|
161 |
|
162 |
|
163 | altRows.removeRowBg('hello');
|
164 |
|
165 |
|
166 | deepEqual(tbl.querySelectorAll('tr.odd').length, 3, 'Expected odd bgs');
|
167 | deepEqual(tbl.querySelectorAll('tr.even').length, 3, 'Expected even bgs');
|
168 | });
|
169 |
|
170 | test('Cannot destroy if not initialised', function() {
|
171 |
|
172 | var getRowsNb = altRows.tf.getRowsNb;
|
173 | var hit = 0;
|
174 | altRows.tf.getRowsNb = function() { hit++; };
|
175 | altRows.initialized = false;
|
176 |
|
177 |
|
178 | altRows.destroy();
|
179 |
|
180 |
|
181 | deepEqual(hit, 0, 'tf.getRowsNb not called');
|
182 |
|
183 | altRows.tf.getRowsNb = getRowsNb;
|
184 | });
|
185 |
|
186 | test('Remove alternating rows', function() {
|
187 |
|
188 | altRows.initialized = true;
|
189 |
|
190 |
|
191 | altRows.destroy();
|
192 |
|
193 |
|
194 | deepEqual(tbl.querySelectorAll('tr.odd').length, 0, 'Odd bgs removed');
|
195 | deepEqual(tbl.querySelectorAll('tr.even').length, 0, 'Even bg removed');
|
196 | });
|
197 |
|
198 | module('Events');
|
199 | test('Can handle `row-processed` event', function() {
|
200 |
|
201 | var processRow = altRows.processRow;
|
202 | var hit = 0;
|
203 | var args;
|
204 | altRows.processRow = function() {
|
205 | args = [].slice.call(arguments);
|
206 | hit++;
|
207 | };
|
208 |
|
209 |
|
210 | altRows.init();
|
211 | tf.emitter.emit('row-processed', tf, 1, 0, true);
|
212 |
|
213 |
|
214 | deepEqual(hit, 1, 'processRow called');
|
215 | deepEqual(args[0], 1, 'processRow called with expected row index');
|
216 | deepEqual(args[1], 0, 'processRow called with expected array index');
|
217 | deepEqual(args[2], true, 'processRow called with expected isValid value');
|
218 |
|
219 | altRows.processRow = processRow;
|
220 | });
|
221 |
|
222 | test('Can handle `row-paged` event', function() {
|
223 |
|
224 | var processRow = altRows.processRow;
|
225 | var hit = 0;
|
226 | var args;
|
227 | altRows.processRow = function() {
|
228 | args = [].slice.call(arguments);
|
229 | hit++;
|
230 | };
|
231 |
|
232 |
|
233 | altRows.init();
|
234 | tf.emitter.emit('row-paged', tf, 1, 0, true);
|
235 |
|
236 |
|
237 | deepEqual(hit, 1, 'processRow called');
|
238 | deepEqual(args[0], 1, 'processRow called with expected row index');
|
239 | deepEqual(args[1], 0, 'processRow called with expected array index');
|
240 | deepEqual(args[2], true, 'processRow called with expected isValid value');
|
241 |
|
242 | altRows.processRow = processRow;
|
243 | });
|
244 |
|
245 | module('Grid layout');
|
246 | test('Grid layout: initialising alternating rows', function() {
|
247 | tf.destroy();
|
248 | tf = null;
|
249 | tf = new TableFilter('demo', {
|
250 | base_path: '../dist/tablefilter/',
|
251 | grid_layout: true,
|
252 | alternate_rows: true
|
253 | });
|
254 | tf.init();
|
255 | tbl = tf.dom();
|
256 | altRows = tf.feature('alternateRows');
|
257 |
|
258 | deepEqual(
|
259 | tbl.querySelectorAll('tr.odd').length, 4, 'Expected bg for odd rows');
|
260 | deepEqual(
|
261 | tbl.querySelectorAll('tr.even').length, 3, 'Expected bg for even rows');
|
262 | });
|
263 |
|
264 | test('Grid layout: filter column', function() {
|
265 | tf.setFilterValue(3, '<2');
|
266 | tf.filter();
|
267 |
|
268 | deepEqual(tbl.querySelectorAll('tr.odd').length, 2, 'Odd bgs removed');
|
269 | deepEqual(tbl.querySelectorAll('tr.even').length, 2, 'Even bg removed');
|
270 | });
|
271 |
|
272 | test('Grid layout: clear filters', function() {
|
273 | tf.clearFilters();
|
274 | tf.filter();
|
275 |
|
276 | deepEqual(tbl.querySelectorAll('tr.odd').length, 4, 'Odd bgs removed');
|
277 | deepEqual(tbl.querySelectorAll('tr.even').length, 3, 'Even bg removed');
|
278 | });
|
279 |
|
280 | test('Grid layout: set background on a row', function() {
|
281 | altRows.setRowBg(4);
|
282 | deepEqual(tbl.rows[4].className, 'odd', 'Bg set on expected row');
|
283 | });
|
284 |
|
285 | test('Grid layout: remove background on a row', function() {
|
286 | altRows.removeRowBg(4);
|
287 | deepEqual(tbl.rows[4].querySelectorAll('.odd').length,
|
288 | 0, 'Bg set on expected row');
|
289 | });
|
290 |
|
291 | test('Grid layout: remove alternating rows', function() {
|
292 | altRows.destroy();
|
293 | deepEqual(tbl.querySelectorAll('tr.odd').length, 0, 'Odd bgs removed');
|
294 | deepEqual(tbl.querySelectorAll('tr.even').length, 0, 'Even bg removed');
|
295 | });
|
296 |
|
297 | module('Fixes');
|
298 |
|
299 | test('Sort: alternating rows with column sorted at start', function() {
|
300 | tf.destroy();
|
301 | tf = null;
|
302 | tf = new TableFilter('demo', {
|
303 | base_path: '../dist/tablefilter/',
|
304 | alternate_rows: true,
|
305 | extensions:[{
|
306 | name: 'sort',
|
307 | sort_col_at_start: [2, true],
|
308 | on_sort_loaded: checkAlternateRows
|
309 | }]
|
310 | });
|
311 | tf.init();
|
312 | altRows = tf.feature('alternateRows');
|
313 |
|
314 | deepEqual(typeof altRows, 'object', 'AlternateRows instanciated');
|
315 | deepEqual(altRows.evenCss, 'even', 'Expected even css class');
|
316 | deepEqual(altRows.oddCss, 'odd', 'Expected odd css class');
|
317 |
|
318 | function checkAlternateRows(tf) {
|
319 | tbl = tf.dom();
|
320 | altRows = tf.feature('alternateRows');
|
321 |
|
322 | test('Alternate rows with sort column at start option', function() {
|
323 | deepEqual(
|
324 | tbl.rows[2].classList.contains('odd'),
|
325 | true,
|
326 | 'Expected bg for rows[2]'
|
327 | );
|
328 | deepEqual(
|
329 | tbl.rows[5].classList.contains('even'),
|
330 | true,
|
331 | 'Expected bg for rows[5]'
|
332 | );
|
333 | });
|
334 | }
|
335 | });
|