Debian Codegraph @

Xcomposer/tests/lib/rule-composer.js

raw
1 'use strict';
2
3 const eslint = require('eslint');
4 const assert = require('chai').assert;
5 const ruleComposer = require('../..');
6
7 const RuleTester = eslint.RuleTester;
8 const ruleTester = new RuleTester();
9 const coreRules = new eslint.Linter().getRules();
10
11 ruleTester.run(
12 'filterReports',
13 ruleComposer.filterReports(coreRules.get('no-undef'), descriptor => descriptor.node && descriptor.node.name !== 'foo'),
14 {
15 valid: [
16 'foo;',
17 'var bar; bar;',
18 ],
19 invalid: [
20 {
21 code: 'bar;',
22 errors: [{ line: 1, column: 1 }],
23 },
24 {
25 code: 'foo; bar;',
26 errors: [{ line: 1, column: 6 }],
27 },
28 {
29 code: 'bar; foo;',
30 errors: [{ line: 1, column: 1 }],
31 },
32 ],
33 }
34 );
35
36 // test with settings
37
38 ruleTester.run(
39 'filterReports - with settings',
40 ruleComposer.filterReports(coreRules.get('no-undef'), (descriptor, m) => (
41 descriptor.node && m.settings.tokenWhitelist.indexOf(descriptor.node.name) === -1
42 )),
43 {
44 valid: [
45 {
46 code: 'foo;',
47 settings: { tokenWhitelist: ['foo'] },
48 },
49 {
50 code: 'var bar; bar;',
51 settings: { tokenWhitelist: ['foo'] },
52 },
53 ],
54 invalid: [
55 {
56 code: 'bar;',
57 errors: [{ line: 1, column: 1 }],
58 settings: { tokenWhitelist: ['foo'] },
59 },
60 {
61 code: 'foo; bar;',
62 errors: [{ line: 1, column: 6 }],
63 settings: { tokenWhitelist: ['foo'] },
64 },
65 {
66 code: 'bar; foo;',
67 errors: [{ line: 1, column: 1 }],
68 settings: { tokenWhitelist: ['foo'] },
69 },
70 ],
71 }
72 );
73
74 const ruleWithOptions = ruleComposer.filterReports(coreRules.get('no-undef'), (descriptor, m) => (
75 descriptor.node && m.options[0].tokenWhitelist.indexOf(descriptor.node.name) === -1
76 ));
77
78 // overwrite schema to allow custom options...
79 ruleWithOptions.meta.schema[0].additionalProperties = true;
80
81 ruleTester.run(
82 'filterReports - with options',
83 ruleWithOptions,
84 {
85 valid: [
86 {
87 code: 'foo;',
88 options: [{ tokenWhitelist: ['foo'] }],
89 },
90 {
91 code: 'var bar; bar;',
92 options: [{ tokenWhitelist: ['foo'] }],
93 },
94 ],
95 invalid: [
96 {
97 code: 'bar;',
98 errors: [{ line: 1, column: 1 }],
99 options: [{ tokenWhitelist: ['foo'] }],
100 },
101 {
102 code: 'foo; bar;',
103 errors: [{ line: 1, column: 6 }],
104 options: [{ tokenWhitelist: ['foo'] }],
105 },
106 {
107 code: 'bar; foo;',
108 errors: [{ line: 1, column: 1 }],
109 options: [{ tokenWhitelist: ['foo'] }],
110 },
111 ],
112 }
113 );
114
115 ruleTester.run(
116 'filterReports with filename',
117 ruleComposer.filterReports(coreRules.get('no-undef'), (descriptor, metadata) => {
118 assert.strictEqual(metadata.filename, 'index.js');
119 return descriptor.node && descriptor.node.name !== 'foo';
120 }),
121 {
122 valid: [
123 {
124 code: 'foo',
125 filename: 'index.js',
126 },
127 {
128 code: 'var bar; bar;',
129 filename: 'index.js',
130 },
131 ],
132 invalid: [
133 {
134 code: 'bar;',
135 errors: [{ line: 1, column: 1 }],
136 filename: 'index.js',
137 },
138 ],
139 }
140 );
141
142 ruleTester.run(
143 'joinReports',
144 ruleComposer.joinReports([
145 context => ({ Program: node => context.report(node, 'foo') }),
146 context => ({ 'Program:exit': node => context.report(node, 'bar') }),
147 { create: context => ({ 'Program:exit': node => context.report(node, 'baz') }) },
148 ]),
149 {
150 valid: [],
151 invalid: [
152 {
153 code: 'a',
154 errors: [
155 { type: 'Program', message: 'foo' },
156 { type: 'Program', message: 'bar' },
157 { type: 'Program', message: 'baz' },
158 ],
159 },
160 ],
161 }
162 );
163
164 ruleTester.run(
165 'mapReports',
166 ruleComposer.mapReports(
167 context => ({ Program: node => context.report({ node, message: 'foo' }) }),
168 descriptor => Object.assign({}, descriptor, { message: descriptor.message.toUpperCase() })
169 ),
170 {
171 valid: [],
172 invalid: [
173 {
174 code: 'a',
175 errors: [
176 { type: 'Program', message: 'FOO' },
177 ],
178 },
179 ],
180 }
181 );
182
183 // test with settings
184
185 ruleTester.run(
186 'mapReports - with settings',
187 ruleComposer.mapReports(
188 context => ({ Program: node => context.report({ node, message: 'foo' }) }),
189 (descriptor, m) => Object.assign({}, descriptor, { message: descriptor.message[m.settings.method]() })
190 ),
191 {
192 valid: [],
193 invalid: [
194 {
195 code: 'a',
196 errors: [
197 { type: 'Program', message: 'FOO' },
198 ],
199 settings: { method: 'toUpperCase' },
200 },
201 ],
202 }
203 );
204
205 // test with settings
206
207 ruleTester.run(
208 'mapReports - with options',
209 ruleComposer.mapReports(
210 context => ({ Program: node => context.report({ node, message: 'foo' }) }),
211 (descriptor, m) => Object.assign({}, descriptor, { message: descriptor.message[m.options[0].method]() })
212 ),
213 {
214 valid: [],
215 invalid: [
216 {
217 code: 'a',
218 errors: [
219 { type: 'Program', message: 'FOO' },
220 ],
221 options: [{ method: 'toUpperCase' }],
222 },
223 ],
224 }
225 );
226
227 ruleTester.run(
228 'mapReports with filename',
229 ruleComposer.mapReports(
230 context => ({ Program: node => context.report({ node, message: 'foo' }) }),
231 (descriptor, metadata) => Object.assign({}, descriptor, { message: metadata.filename })
232 ),
233 {
234 valid: [],
235 invalid: [
236 {
237 code: 'a',
238 filename: 'test.js',
239 errors: [
240 { type: 'Program', message: 'test.js' },
241 ],
242 },
243 ],
244 }
245 );
246
247 ruleTester.run(
248 'checking the first token of the report',
249 ruleComposer.filterReports(
250 coreRules.get('no-unused-expressions'),
251 (problem, metadata) => metadata.sourceCode.getFirstToken(problem.node).value !== 'expect'
252 ),
253 {
254 valid: [
255 'expect(foo).to.be.true;',
256 'expect;',
257 ],
258 invalid: [
259 {
260 code: 'foo;',
261 errors: 1,
262 },
263 ],
264 }
265 );
266
267 ruleTester.run(
268 'composing rules that use messageId',
269 ruleComposer.filterReports(
270 {
271 meta: {
272 messages: {
273 foo: 'Foo error.',
274 bar: 'Bar error.',
275 baz: 'Baz error {{myData}}.',
276 },
277 },
278 create(context) {
279 return {
280 Program(node) {
281 context.report({ node, messageId: 'foo' });
282 context.report({ node, messageId: 'bar' });
283 context.report({ node, messageId: 'baz', data: { myData: 'BAZ', otherData: 'blah' } });
284 context.report({ node, message: 'Not message id {{aa}}', data: { aa: 'foo' } });
285 },
286 };
287 },
288 },
289 (problem) => {
290 if (problem.messageId === 'baz') {
291 assert.strictEqual(problem.message, 'Baz error BAZ.');
292 assert.deepEqual(problem.data, { myData: 'BAZ' });
293 } else if (problem.messageId === 'foo') {
294 assert.strictEqual(problem.message, 'Foo error.');
295 assert.deepEqual(problem.data, {});
296 } else if (problem.messageId === 'bar') {
297 assert.strictEqual(problem.message, 'Bar error.');
298 assert.deepEqual(problem.data, {});
299 } else if (problem.messageId === null) {
300 assert.strictEqual(problem.message, 'Not message id foo');
301 assert.strictEqual(problem.data, null);
302 } else {
303 assert.fail('Unexpected reported problem');
304 }
305
306 return problem.message === 'Foo error.' || problem.messageId === 'baz';
307 }
308 ),
309 {
310 valid: [],
311 invalid: [
312 {
313 code: 'x',
314 errors: [
315 { type: 'Program', message: 'Foo error.' },
316 { type: 'Program', message: 'Baz error BAZ.' },
317 ],
318 },
319 ],
320 }
321 );