1 |
|
2 | var tf = new TableFilter('demo', {
|
3 | base_path: '../dist/tablefilter/',
|
4 | state: true
|
5 | });
|
6 | tf.init();
|
7 | var state = tf.feature('state');
|
8 | module('Sanity checks');
|
9 | test('State instance', function() {
|
10 | deepEqual(tf.state, true, 'State is enabled');
|
11 | deepEqual(typeof state, 'object', 'State is instantiated');
|
12 | deepEqual(state.initialized, true, 'State is initialized');
|
13 | deepEqual(state.enableHash, true, 'Hash is enabled by default');
|
14 | deepEqual(state.persistFilters, true, 'Filters are persisted by default');
|
15 | deepEqual(state.persistPageNumber, false, 'Page number not persisted');
|
16 | deepEqual(state.persistPageLength, false, 'Page length not persisted');
|
17 | deepEqual(typeof state.state, 'object', 'State field is an object');
|
18 | });
|
19 |
|
20 | test('Should not initialize if already initialized', function() {
|
21 |
|
22 | var hit = 0;
|
23 | state.initialized = true;
|
24 | var initialHashInit = state.hash.init;
|
25 | state.hash.init = function() {
|
26 | hit++;
|
27 | };
|
28 |
|
29 |
|
30 | state.init();
|
31 |
|
32 |
|
33 | deepEqual(hit, 0, 'hash init not called');
|
34 |
|
35 | state.hash.init = initialHashInit;
|
36 | });
|
37 |
|
38 | module('Behaviour');
|
39 | test('Can update filters state', function() {
|
40 |
|
41 | state.state = {};
|
42 |
|
43 |
|
44 | tf.setFilterValue(1, 'Adelaide');
|
45 | tf.filter();
|
46 |
|
47 |
|
48 | deepEqual(state.state.col_1, { 'flt': 'Adelaide' },
|
49 | 'State object updated');
|
50 | });
|
51 |
|
52 | test('Can update state when previously field value is set empty', function() {
|
53 |
|
54 | state.state = {};
|
55 | tf.setFilterValue(0, 'Sydney');
|
56 | tf.filter();
|
57 |
|
58 |
|
59 | tf.setFilterValue(0, '');
|
60 | tf.filter();
|
61 |
|
62 |
|
63 | deepEqual(state.state.col_0, { 'flt': undefined },
|
64 | 'State object updated');
|
65 | });
|
66 |
|
67 | test('Can update on clear filters', function() {
|
68 |
|
69 | state.state = {};
|
70 |
|
71 |
|
72 | tf.clearFilters();
|
73 |
|
74 |
|
75 | deepEqual(state.state.col_1, undefined, 'State object updated');
|
76 | });
|
77 |
|
78 | test('Can update page number', function() {
|
79 |
|
80 | state.state = {};
|
81 | state.pageNb = 2;
|
82 | state.persistPageNumber = true;
|
83 |
|
84 |
|
85 | tf.filter();
|
86 | state.persistPageNumber = false;
|
87 |
|
88 |
|
89 | deepEqual(state.state.page, 2, 'Page number updated');
|
90 | });
|
91 |
|
92 | test('Can update page number when null', function() {
|
93 |
|
94 | state.state = {};
|
95 | state.pageNb = null;
|
96 | state.persistPageNumber = true;
|
97 |
|
98 |
|
99 | tf.filter();
|
100 | state.persistPageNumber = false;
|
101 |
|
102 |
|
103 | deepEqual(state.state.page, undefined, 'Page number updated');
|
104 | });
|
105 |
|
106 | test('Can update page length', function() {
|
107 |
|
108 | state.persistPageLength = true;
|
109 | state.state = {};
|
110 | state.pageLength = 10;
|
111 |
|
112 |
|
113 | tf.filter();
|
114 | state.persistPageLength = false;
|
115 |
|
116 |
|
117 | deepEqual(state.state.page_length, 10, 'Page length updated');
|
118 | });
|
119 |
|
120 | test('Can update page length when null', function() {
|
121 |
|
122 | state.persistPageLength = true;
|
123 | state.state = {};
|
124 | state.pageLength = null;
|
125 |
|
126 |
|
127 | tf.filter();
|
128 | state.persistPageLength = false;
|
129 |
|
130 |
|
131 | deepEqual(state.state.page_length, undefined, 'Page length updated');
|
132 | });
|
133 |
|
134 | test('Can update sort', function() {
|
135 |
|
136 | state.persistSort = true;
|
137 | state.state = {};
|
138 |
|
139 |
|
140 | tf.emitter.emit('column-sorted', tf, 1, true);
|
141 | state.persistSort = false;
|
142 |
|
143 |
|
144 | deepEqual(state.state.col_1,
|
145 | { 'sort': { 'descending': true } }, 'Sort updated');
|
146 | });
|
147 |
|
148 | test('Can update sort when previously set', function() {
|
149 |
|
150 | state.persistSort = true;
|
151 | state.state = { col_1: { 'sort': { 'descending': true } } };
|
152 |
|
153 |
|
154 | tf.emitter.emit('column-sorted', tf, 0, false);
|
155 | state.persistSort = false;
|
156 |
|
157 |
|
158 | deepEqual(state.state.col_0,
|
159 | { 'sort': { 'descending': false } }, 'Sort updated');
|
160 | deepEqual(state.state.col_1.sort, undefined, 'Sort updated');
|
161 | });
|
162 |
|
163 | test('Can update columns visibility', function() {
|
164 |
|
165 | state.persistColsVisibility = true;
|
166 | state.state = {};
|
167 |
|
168 |
|
169 | tf.emitter.emit('column-shown', tf, {}, 1, [0, 2]);
|
170 | state.persistColsVisibility = false;
|
171 |
|
172 |
|
173 | deepEqual(state.state.col_0.hidden, true, 'Column 0 visibility updated');
|
174 | deepEqual(state.state.col_2.hidden, true, 'Column 2 visibility updated');
|
175 | });
|
176 |
|
177 | test('Can update columns visibility when already set', function() {
|
178 |
|
179 | state.persistColsVisibility = true;
|
180 | state.state = {
|
181 | col_0: { hidden: true },
|
182 | col_2: { hidden: true }
|
183 | };
|
184 |
|
185 |
|
186 | tf.emitter.emit('column-shown', tf, {}, 1, []);
|
187 | state.persistColsVisibility = false;
|
188 |
|
189 |
|
190 | deepEqual(state.state.col_0.hidden, undefined,
|
191 | 'Column 0 visibility updated');
|
192 | deepEqual(state.state.col_2.hidden, undefined,
|
193 | 'Column 2 visibility updated');
|
194 | });
|
195 |
|
196 | test('Can update filters visibility', function() {
|
197 |
|
198 | state.persistFiltersVisibility = true;
|
199 | state.state = {};
|
200 |
|
201 |
|
202 | tf.emitter.emit('filters-toggled', tf, {}, false);
|
203 | state.persistFiltersVisibility = false;
|
204 |
|
205 |
|
206 | deepEqual(state.state.filters_visibility, false,
|
207 | 'Filters visibility updated');
|
208 | });
|
209 |
|
210 | test('Can update filters visibility when null', function() {
|
211 |
|
212 | state.persistFiltersVisibility = true;
|
213 | state.state = {};
|
214 | state.filtersVisibility = null;
|
215 |
|
216 |
|
217 | state.update();
|
218 | state.persistFiltersVisibility = false;
|
219 |
|
220 |
|
221 | deepEqual(state.state.filters_visibility, undefined,
|
222 | 'Filters visibility updated');
|
223 | });
|
224 |
|
225 | test('Can sync state', function() {
|
226 |
|
227 | state.state = {};
|
228 | state.state.col_2 = { 'flt': '>1500' };
|
229 |
|
230 |
|
231 | state.sync();
|
232 |
|
233 |
|
234 | deepEqual(tf.getValidRows(), [6, 7, 8], 'Table filters are synced');
|
235 | });
|
236 |
|
237 | test('Can override state', function() {
|
238 |
|
239 | var hit = 0;
|
240 | var initialEmit = state.emitter.emit;
|
241 | var args = null;
|
242 | state.emitter.emit = function() {
|
243 | args = arguments;
|
244 | hit++;
|
245 | };
|
246 | state.state = {};
|
247 |
|
248 |
|
249 | state.override({ 'col_1': { 'flt': 'Ade' } });
|
250 |
|
251 |
|
252 | deepEqual(state.state, { 'col_1': { 'flt': 'Ade' } },
|
253 | 'State field overriden');
|
254 | deepEqual(hit, 1, 'event emitted');
|
255 | deepEqual(args[0], 'state-changed', 'event name');
|
256 | deepEqual(args[1], tf, 'tf parameter');
|
257 | deepEqual(args[2], state.state, 'state parameter');
|
258 |
|
259 | state.emitter.emit = initialEmit;
|
260 | });
|
261 |
|
262 | test('Can override and sync state', function() {
|
263 |
|
264 | state.state = {};
|
265 |
|
266 |
|
267 | state.overrideAndSync({ 'col_2': { 'flt': '1412' } });
|
268 |
|
269 |
|
270 | deepEqual(state.state, { 'col_2': { 'flt': '1412' } },
|
271 | 'State field overriden');
|
272 | deepEqual(tf.getValidRows(), [2], 'Table filters are synced');
|
273 | });
|
274 |
|
275 | test('Can update page number', function() {
|
276 |
|
277 | state.persistPageNumber = true;
|
278 | state.state = {};
|
279 |
|
280 |
|
281 | state.updatePage('2');
|
282 | state.persistPageNumber = false;
|
283 |
|
284 |
|
285 | deepEqual(state.state.page, '2', 'Page number updated');
|
286 | });
|
287 |
|
288 | test('Can update page length', function() {
|
289 |
|
290 | state.persistPageLength = true;
|
291 | state.state = {};
|
292 |
|
293 |
|
294 | state.updatePageLength('10');
|
295 | state.persistPageLength = false;
|
296 |
|
297 |
|
298 | deepEqual(state.state.page_length, '10', 'Page length updated');
|
299 | });
|
300 |
|
301 | test('Can update sort', function() {
|
302 |
|
303 | state.persistSort = true;
|
304 | state.state = {};
|
305 |
|
306 |
|
307 | state.updateSort(1, true);
|
308 | state.persistSort = false;
|
309 |
|
310 |
|
311 | deepEqual(state.state.col_1,
|
312 | { 'sort': { 'descending': true } }, 'Sort updated');
|
313 | });
|
314 |
|
315 | test('Can update columns visibility', function() {
|
316 |
|
317 | state.persistColsVisibility = true;
|
318 | state.state = {};
|
319 |
|
320 |
|
321 | state.updateColsVisibility([0, 2]);
|
322 | state.persistColsVisibility = false;
|
323 |
|
324 |
|
325 | deepEqual(state.state.col_0.hidden, true, 'Column 0 visibility updated');
|
326 | deepEqual(state.state.col_2.hidden, true, 'Column 2 visibility updated');
|
327 | });
|
328 |
|
329 | test('Can update filters visibility', function() {
|
330 |
|
331 | state.persistFiltersVisibility = true;
|
332 | state.state = {};
|
333 |
|
334 |
|
335 | state.updateFiltersVisibility(false);
|
336 | state.persistFiltersVisibility = false;
|
337 |
|
338 |
|
339 | deepEqual(state.state.filters_visibility, false,
|
340 | 'Filters visibility updated');
|
341 | });
|
342 |
|
343 | test('sync filters can clear filters before applying state', function() {
|
344 |
|
345 | state.state = {'col_0': { 'flt': 'Ade' }};
|
346 | tf.setFilterValue(1, 'Can');
|
347 | tf.setFilterValue(2, '1412');
|
348 |
|
349 |
|
350 | state._syncFilters();
|
351 |
|
352 |
|
353 | deepEqual(tf.getFilterValue(1), '', 'filter 1 cleared');
|
354 | deepEqual(tf.getFilterValue(2), '', 'filter 2 cleared');
|
355 | deepEqual(tf.getFilterValue(0), 'Ade', 'filter 0 state value applied');
|
356 | deepEqual(tf.getValidRows(), [6, 7, 8], 'Filtered rows');
|
357 | });
|
358 |
|
359 | module('Tear-down');
|
360 | test('Can destroy TF', function() {
|
361 |
|
362 | location.hash = null;
|
363 |
|
364 |
|
365 | tf.destroy();
|
366 |
|
367 |
|
368 | deepEqual(state.initialized, false, 'State not initialized');
|
369 | });
|