UNPKG

8.9 kBJavaScriptView Raw
1(function(win, TableFilter){
2
3 var tf = new TableFilter('demo', {
4 base_path: '../dist/tablefilter/'
5 });
6 tf.init();
7
8 module('Sanity checks');
9 test('Filters', function() {
10 deepEqual(tf instanceof TableFilter, true, 'TableFilter instanciated');
11 notEqual(tf.getFilterElement(0), null, 'Filter generated');
12 });
13
14 module('Operators');
15 test('Regex operator - rgx:', function() {
16 tf.setFilterValue(3, 'rgx:[4-5]');
17 tf.filter();
18 var filteredData = tf.getFilteredData();
19 deepEqual(tf.getValidRows().length, 3, 'Expected number of matches');
20 deepEqual(
21 filteredData[1],
22 [3, ['Sydney', 'Brisbane', '982', '1.5', '16']],
23 'Expected row data'
24 );
25 });
26
27 test('Regex operator - rgx:b.*e', function() {
28 tf.clearFilters();
29 tf.setFilterValue(1, 'rgx:b.*e');
30 tf.filter();
31 var filteredData = tf.getFilteredData();
32 deepEqual(tf.getValidRows().length, 4, 'Expected number of matches');
33 deepEqual(
34 filteredData[3],
35 [8, ['Adelaide', 'Brisbane', '2045', '2.15', '40']],
36 'Expected row data'
37 );
38 });
39
40 test('Regex operator - rgx:b.+e', function() {
41 tf.clearFilters();
42 tf.setFilterValue(1, 'rgx:b.+e');
43 tf.filter();
44 var filteredData = tf.getFilteredData();
45 deepEqual(tf.getValidRows().length, 3, 'Expected number of matches');
46 deepEqual(
47 filteredData[2],
48 [8, ['Adelaide', 'Brisbane', '2045', '2.15', '40']],
49 'Expected row data'
50 );
51 });
52
53 test('Empty operator - [empty]', function() {
54 var cell = tf.getWorkingRows()[4].cells[4];
55 cell.innerHTML = '';
56 tf.clearFilters();
57 tf.setFilterValue(4, '[empty]');
58 tf.filter();
59 var filteredData = tf.getFilteredData();
60
61 deepEqual(tf.getValidRows().length, 1, 'Expected number of matches');
62 deepEqual(
63 filteredData[0],
64 [6, ['Adelaide', 'Perth', '2781', '3.1', '']],
65 'Expected row data'
66 );
67 });
68
69 test('Empty operator - with cell containing dom element', function() {
70 var cell = tf.getWorkingRows()[4].cells[4];
71 cell.innerHTML = '<img>';
72 tf.clearFilters();
73 tf.setFilterValue(4, '[empty]');
74 tf.filter();
75 var filteredData = tf.getFilteredData();
76
77 deepEqual(tf.getValidRows().length, 1, 'Expected match');
78 deepEqual(
79 filteredData[0],
80 [6, ['Adelaide', 'Perth', '2781', '3.1', '']],
81 'Expected row data'
82 );
83 });
84
85 test('Non-empty operator - [nonempty]', function() {
86 var cell = tf.getWorkingRows()[4].cells[4];
87 cell.innerHTML = '';
88 tf.clearFilters();
89 tf.setFilterValue(4, '[nonempty]');
90 tf.filter();
91 var filteredData = tf.getFilteredData();
92 deepEqual(tf.getValidRows().length, 6, 'Expected number of matches');
93 deepEqual(
94 filteredData[5],
95 [8, ['Adelaide', 'Brisbane', '2045', '2.15', '40']],
96 'Expected row data');
97 });
98
99 test('Non-empty operator - with cell containing dom element', function() {
100 var cell = tf.getWorkingRows()[4].cells[4];
101 cell.innerHTML = '<img>';
102 tf.clearFilters();
103 tf.setFilterValue(4, '[nonempty]');
104 tf.filter();
105
106 deepEqual(tf.getValidRows().length, 6, 'Expected number of matches');
107 });
108
109 test('Or operator - ||', function() {
110 tf.clearFilters();
111 tf.setFilterValue(1, 'Canberra||Alice Springs');
112 tf.filter();
113 var filteredData = tf.getFilteredData();
114 deepEqual(tf.getValidRows().length, 2, 'Expected number of matches');
115 deepEqual(
116 filteredData[1],
117 [7, ['Adelaide', 'Alice Springs', '1533', '2', '20.25']],
118 'Expected row data'
119 );
120 });
121
122 test('And operator - &&', function() {
123 tf.clearFilters();
124 tf.setFilterValue(1, 'Al&&Spr');
125 tf.filter();
126 var filteredData = tf.getFilteredData();
127 deepEqual(tf.getValidRows().length, 1, 'Expected number of matches');
128 deepEqual(
129 filteredData[0],
130 [7, ['Adelaide', 'Alice Springs', '1533', '2', '20.25']],
131 'Expected row data'
132 );
133 });
134
135 test('Greater than operator - >', function() {
136 tf.clearFilters();
137 tf.setFilterValue(2, '>1600');
138 tf.filter();
139 var filteredData = tf.getFilteredData();
140 deepEqual(tf.getValidRows().length, 2, 'Expected number of matches');
141 deepEqual(
142 filteredData[1],
143 [8, ['Adelaide', 'Brisbane', '2045', '2.15', '40']],
144 'Expected row data'
145 );
146 });
147
148 test('Lower than operator - <', function() {
149 tf.clearFilters();
150 tf.setFilterValue(3, '<1.5');
151 tf.filter();
152 var filteredData = tf.getFilteredData();
153 deepEqual(tf.getValidRows().length, 3, 'Expected number of matches');
154 deepEqual(
155 filteredData[2],
156 [5, ['Sydney', 'Melbourne', '872', '1.1', '10.5']],
157 'Expected row data'
158 );
159 });
160
161 test('Greater than or equal to operator - >=', function() {
162 tf.clearFilters();
163 tf.setFilterValue(2, '>=2781');
164 tf.filter();
165 var filteredData = tf.getFilteredData();
166 deepEqual(tf.getValidRows().length, 1, 'Expected number of matches');
167 deepEqual(
168 filteredData[0],
169 [6, ['Adelaide', 'Perth', '2781', '3.1', '']],
170 'Expected row data'
171 );
172 });
173
174 test('Lower than or equal to operator - <=', function() {
175 tf.clearFilters();
176 tf.setFilterValue(3, '<=0.6');
177 tf.filter();
178 var filteredData = tf.getFilteredData();
179 deepEqual(tf.getValidRows().length, 1, 'Expected number of matches');
180 deepEqual(
181 filteredData[0],
182 [4, ['Sydney', 'Canberra', '286', '.6', '4.3']],
183 'Expected row data'
184 );
185 });
186
187 test('Different from operator - !', function() {
188 tf.clearFilters();
189 tf.setFilterValue(0, '!Sydney');
190 tf.filter();
191 var filteredData = tf.getFilteredData();
192 deepEqual(tf.getValidRows().length, 3, 'Expected number of matches');
193 deepEqual(
194 filteredData[2],
195 [8, ['Adelaide', 'Brisbane', '2045', '2.15', '40']],
196 'Expected row data'
197 );
198 });
199
200 test('Like operator - *', function() {
201 tf.clearFilters();
202 tf.setFilterValue(1, '*our');
203 tf.filter();
204 var filteredData = tf.getFilteredData();
205 deepEqual(tf.getValidRows().length, 1, 'Expected number of matches');
206 deepEqual(
207 filteredData[0],
208 [5, ['Sydney', 'Melbourne', '872', '1.1', '10.5']],
209 'Expected row data'
210 );
211 });
212
213 test('Equal operator - =', function() {
214 tf.clearFilters();
215 tf.setFilterValue(1, '=Pe');
216 tf.filter();
217 deepEqual(tf.getValidRows().length, 0, 'Expected number of matches');
218
219 tf.clearFilters();
220 tf.setFilterValue(1, '=Perth');
221 tf.filter();
222 var filteredData = tf.getFilteredData();
223 deepEqual(tf.getValidRows().length, 1, 'Expected number of matches');
224 deepEqual(
225 filteredData[0],
226 [6, ['Adelaide', 'Perth', '2781', '3.1', '']],
227 'Expected row data'
228 );
229 });
230
231 test('Starts with - {', function() {
232 tf.clearFilters();
233 tf.setFilterValue(1, '{a');
234 tf.filter();
235 var filteredData = tf.getFilteredData();
236 deepEqual(tf.getValidRows().length, 2, 'Expected number of matches');
237 deepEqual(
238 filteredData[0],
239 [2, ['Sydney', 'Adelaide', '1412', '1.4', '25.3']],
240 'Expected row data'
241 );
242 });
243
244 test('Ends with - }', function() {
245 tf.clearFilters();
246 tf.setFilterValue(1, '}e');
247 tf.filter();
248 var filteredData = tf.getFilteredData();
249 deepEqual(tf.getValidRows().length, 4, 'Expected number of matches');
250 deepEqual(
251 filteredData[0],
252 [2, ['Sydney', 'Adelaide', '1412', '1.4', '25.3']],
253 'Expected row data'
254 );
255 });
256
257 module('Tear-down');
258 test('can destroy TableFilter DOM elements', function() {
259 tf.clearFilters();
260 tf.destroy();
261 deepEqual(tf.isInitialized(), false, 'Filters removed');
262 });
263
264})(window, TableFilter);