2 * @fileoverview Tests for space-before-block rule.
3 * @author Mathias Schreck <https://github.com/lo1tuma>
8 //------------------------------------------------------------------------------
10 //------------------------------------------------------------------------------
12 const rule
= require("../../../lib/rules/space-before-blocks"),
13 { RuleTester
} = require("../../../lib/rule-tester");
15 //------------------------------------------------------------------------------
17 //------------------------------------------------------------------------------
19 const ruleTester
= new RuleTester(),
20 neverArgs
= ["never"],
21 functionsOnlyArgs
= [{ functions
: "always", keywords
: "never", classes
: "never" }],
22 keywordOnlyArgs
= [{ functions
: "never", keywords
: "always", classes
: "never" }],
23 classesOnlyArgs
= [{ functions
: "never", keywords
: "never", classes
: "always" }],
24 functionsAlwaysOthersOffArgs
= [{ functions
: "always", keywords
: "off", classes
: "off" }],
25 keywordAlwaysOthersOffArgs
= [{ functions
: "off", keywords
: "always", classes
: "off" }],
26 classesAlwaysOthersOffArgs
= [{ functions
: "off", keywords
: "off", classes
: "always" }],
27 functionsNeverOthersOffArgs
= [{ functions
: "never", keywords
: "off", classes
: "off" }],
28 keywordNeverOthersOffArgs
= [{ functions
: "off", keywords
: "never", classes
: "off" }],
29 classesNeverOthersOffArgs
= [{ functions
: "off", keywords
: "off", classes
: "never" }],
30 expectedSpacingError
= { messageId
: "missingSpace" },
31 expectedNoSpacingError
= { messageId
: "unexpectedSpace" };
33 ruleTester
.run("space-before-blocks", rule
, {
37 { code
: "if(a){}", options
: neverArgs
},
38 { code
: "if(a){}", options
: functionsOnlyArgs
},
39 { code
: "if(a) {}", options
: keywordOnlyArgs
},
40 { code
: "if(a){ function b() {} }", options
: functionsOnlyArgs
},
41 { code
: "if(a) { function b(){} }", options
: keywordOnlyArgs
},
43 { code
: "if(a)\n{}", options
: neverArgs
},
45 { code
: "if(a){}else{}", options
: neverArgs
},
46 { code
: "if(a){}else{}", options
: functionsOnlyArgs
},
47 { code
: "if(a) {} else {}", options
: keywordOnlyArgs
},
48 { code
: "if(a){ function b() {} }else{}", options
: functionsOnlyArgs
},
49 { code
: "if(a) { function b(){} } else {}", options
: keywordOnlyArgs
},
51 { code
: "function a(){}", options
: neverArgs
},
53 code
: "export default class{}",
54 options
: functionsOnlyArgs
,
55 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" }
58 code
: "export default class {}",
59 options
: classesOnlyArgs
,
60 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" }
63 code
: "export default function a() {}",
64 options
: functionsOnlyArgs
,
65 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" }
68 code
: "export default function a(){}",
69 options
: keywordOnlyArgs
,
70 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" }
72 { code
: "export function a(){}", options
: keywordOnlyArgs
, parserOptions
: { ecmaVersion
: 6, sourceType
: "module" } },
73 { code
: "export function a() {}", options
: functionsOnlyArgs
, parserOptions
: { ecmaVersion
: 6, sourceType
: "module" } },
74 { code
: "function a(){}", options
: keywordOnlyArgs
},
75 { code
: "function a() {}", options
: functionsOnlyArgs
},
76 { code
: "function a(){ if(b) {} }", options
: keywordOnlyArgs
},
77 { code
: "function a() { if(b){} }", options
: functionsOnlyArgs
},
78 "switch(a.b(c < d)) { case 'foo': foo(); break; default: if (a) { bar(); } }",
81 { code
: "switch(a.b(c < d)){ case 'foo': foo(); break; default: if (a){ bar(); } }", options
: neverArgs
},
82 { code
: "switch(a.b(c < d)){ case 'foo': foo(); break; default: if (a){ bar(); } }", options
: functionsOnlyArgs
},
83 { code
: "switch(a){}", options
: neverArgs
},
84 { code
: "switch(a){}", options
: functionsOnlyArgs
},
85 { code
: "switch(a) {}", options
: keywordOnlyArgs
},
87 { code
: "try{}catch(a){}", options
: neverArgs
},
88 { code
: "try{}catch(a){}", options
: functionsOnlyArgs
},
89 { code
: "try {} catch(a) {}", options
: keywordOnlyArgs
},
90 { code
: "try{ function b() {} }catch(a){}", options
: functionsOnlyArgs
},
91 { code
: "try { function b(){} } catch(a) {}", options
: keywordOnlyArgs
},
93 { code
: "for(;;){}", options
: neverArgs
},
94 { code
: "for(;;){}", options
: functionsOnlyArgs
},
95 { code
: "for(;;) {}", options
: keywordOnlyArgs
},
96 { code
: "for(;;){ function a() {} }", options
: functionsOnlyArgs
},
97 { code
: "for(;;) { function a(){} }", options
: keywordOnlyArgs
},
99 { code
: "while(a){}", options
: neverArgs
},
100 { code
: "while(a){}", options
: functionsOnlyArgs
},
101 { code
: "while(a) {}", options
: keywordOnlyArgs
},
102 { code
: "while(a){ function b() {} }", options
: functionsOnlyArgs
},
103 { code
: "while(a) { function b(){} }", options
: keywordOnlyArgs
},
105 code
: "class test { constructor() {} }",
106 options
: [{ functions
: "always", keywords
: "never" }],
107 parserOptions
: { ecmaVersion
: 6 }
110 code
: "class test { constructor(){} }",
111 options
: classesOnlyArgs
,
112 parserOptions
: { ecmaVersion
: 6 }
115 code
: "class test{ constructor() {} }",
116 options
: functionsOnlyArgs
,
117 parserOptions
: { ecmaVersion
: 6 }
120 code
: "class test {}",
121 options
: classesOnlyArgs
,
122 parserOptions
: { ecmaVersion
: 6 }
125 code
: "class test{}",
126 options
: functionsOnlyArgs
,
127 parserOptions
: { ecmaVersion
: 6 }
130 code
: "class test{}",
132 parserOptions
: { ecmaVersion
: 6 }
135 code
: "class test {}",
136 parserOptions
: { ecmaVersion
: 6 }
138 { code
: "function a(){if(b) {}}", options
: keywordAlwaysOthersOffArgs
},
139 { code
: "function a() {if(b) {}}", options
: keywordAlwaysOthersOffArgs
},
140 { code
: "function a() {if(b){}}", options
: functionsAlwaysOthersOffArgs
},
141 { code
: "function a() {if(b) {}}", options
: functionsAlwaysOthersOffArgs
},
143 code
: "class test { constructor(){if(a){}} }",
144 options
: classesAlwaysOthersOffArgs
,
145 parserOptions
: { ecmaVersion
: 6 }
148 code
: "class test { constructor() {if(a){}} }",
149 options
: classesAlwaysOthersOffArgs
,
150 parserOptions
: { ecmaVersion
: 6 }
153 code
: "class test { constructor(){if(a) {}} }",
154 options
: classesAlwaysOthersOffArgs
,
155 parserOptions
: { ecmaVersion
: 6 }
158 code
: "class test { constructor() {if(a) {}} }",
159 options
: classesAlwaysOthersOffArgs
,
160 parserOptions
: { ecmaVersion
: 6 }
162 { code
: "function a(){if(b){}}", options
: keywordNeverOthersOffArgs
},
163 { code
: "function a() {if(b){}}", options
: keywordNeverOthersOffArgs
},
164 { code
: "function a(){if(b){}}", options
: functionsNeverOthersOffArgs
},
165 { code
: "function a(){if(b) {}}", options
: functionsNeverOthersOffArgs
},
167 code
: "class test{ constructor(){if(a){}} }",
168 options
: classesNeverOthersOffArgs
,
169 parserOptions
: { ecmaVersion
: 6 }
172 code
: "class test{ constructor() {if(a){}} }",
173 options
: classesNeverOthersOffArgs
,
174 parserOptions
: { ecmaVersion
: 6 }
177 code
: "class test{ constructor(){if(a) {}} }",
178 options
: classesNeverOthersOffArgs
,
179 parserOptions
: { ecmaVersion
: 6 }
182 code
: "class test{ constructor() {if(a) {}} }",
183 options
: classesNeverOthersOffArgs
,
184 parserOptions
: { ecmaVersion
: 6 }
187 // https://github.com/eslint/eslint/issues/3769
188 { code
: "()=>{};", options
: ["always"], parserOptions
: { ecmaVersion
: 6 } },
189 { code
: "() => {};", options
: ["never"], parserOptions
: { ecmaVersion
: 6 } },
191 // https://github.com/eslint/eslint/issues/1338
193 { code
: "if(a){}else {}", options
: neverArgs
},
194 { code
: "try {}catch(a){}", options
: functionsOnlyArgs
},
195 { code
: "export default class{}", options
: classesOnlyArgs
, parserOptions
: { ecmaVersion
: 6, sourceType
: "module" } }
201 errors
: [{ messageId
: "missingSpace", line
: 1, column
: 6 }]
206 options
: keywordOnlyArgs
,
207 errors
: [expectedSpacingError
]
212 options
: functionsOnlyArgs
,
213 errors
: [expectedNoSpacingError
]
216 code
: "if(a) { function a() {} }",
217 output
: "if(a){ function a() {} }",
218 options
: functionsOnlyArgs
,
219 errors
: [{ messageId
: "unexpectedSpace", line
: 1, column
: 7 }]
222 code
: "if(a) { function a() {} }",
223 output
: "if(a) { function a(){} }",
224 options
: keywordOnlyArgs
,
225 errors
: [{ messageId
: "unexpectedSpace", line
: 1, column
: 22 }]
231 errors
: [expectedNoSpacingError
]
234 code
: "function a(){}",
235 output
: "function a() {}",
236 errors
: [expectedSpacingError
]
239 code
: "function a() {}",
240 output
: "function a(){}",
242 errors
: [expectedNoSpacingError
]
245 code
: "function a() {}",
246 output
: "function a(){}",
248 errors
: [expectedNoSpacingError
]
251 code
: "function a(){ if (a){} }",
252 output
: "function a() { if (a){} }",
253 options
: functionsOnlyArgs
,
254 errors
: [{ messageId
: "missingSpace", line
: 1, column
: 13 }]
257 code
: "function a() { if (a) {} }",
258 output
: "function a(){ if (a) {} }",
259 options
: keywordOnlyArgs
,
260 errors
: [{ messageId
: "unexpectedSpace", line
: 1, column
: 14 }]
263 code
: "function a(){}",
264 output
: "function a() {}",
265 options
: functionsOnlyArgs
,
266 errors
: [expectedSpacingError
]
269 code
: "function a() {}",
270 output
: "function a(){}",
271 options
: keywordOnlyArgs
,
272 errors
: [expectedNoSpacingError
]
276 output
: "switch(a) {}",
277 errors
: [expectedSpacingError
]
280 code
: "switch(a) {}",
281 output
: "switch(a){}",
283 errors
: [expectedNoSpacingError
]
287 output
: "switch(a) {}",
288 options
: keywordOnlyArgs
,
289 errors
: [expectedSpacingError
]
292 code
: "switch(a) {}",
293 output
: "switch(a){}",
294 options
: functionsOnlyArgs
,
295 errors
: [expectedNoSpacingError
]
298 code
: "switch(a.b()){ case 'foo': foo(); break; default: if (a) { bar(); } }",
299 output
: "switch(a.b()) { case 'foo': foo(); break; default: if (a) { bar(); } }",
300 errors
: [expectedSpacingError
]
303 code
: "switch(a.b()) { case 'foo': foo(); break; default: if (a){ bar(); } }",
304 output
: "switch(a.b()){ case 'foo': foo(); break; default: if (a){ bar(); } }",
306 errors
: [expectedNoSpacingError
]
309 code
: "try{}catch(a){}",
310 output
: "try{}catch(a) {}",
311 errors
: [expectedSpacingError
]
314 code
: "try {}catch(a) {}",
315 output
: "try {}catch(a){}",
317 errors
: [expectedNoSpacingError
]
320 code
: "try {} catch(a){}",
321 output
: "try {} catch(a) {}",
322 options
: keywordOnlyArgs
,
323 errors
: [expectedSpacingError
]
326 code
: "try { function b() {} } catch(a) {}",
327 output
: "try { function b(){} } catch(a) {}",
328 options
: keywordOnlyArgs
,
329 errors
: [{ messageId
: "unexpectedSpace", line
: 1, column
: 20 }]
332 code
: "try{ function b(){} }catch(a){}",
333 output
: "try{ function b() {} }catch(a){}",
334 options
: functionsOnlyArgs
,
335 errors
: [{ messageId
: "missingSpace", line
: 1, column
: 18 }]
339 output
: "for(;;) {}",
340 errors
: [expectedSpacingError
]
346 errors
: [expectedNoSpacingError
]
350 output
: "for(;;) {}",
351 options
: keywordOnlyArgs
,
352 errors
: [expectedSpacingError
]
357 options
: functionsOnlyArgs
,
358 errors
: [expectedNoSpacingError
]
361 code
: "for(;;){ function a(){} }",
362 output
: "for(;;){ function a() {} }",
363 options
: functionsOnlyArgs
,
364 errors
: [expectedSpacingError
]
367 code
: "for(;;) { function a() {} }",
368 output
: "for(;;) { function a(){} }",
369 options
: keywordOnlyArgs
,
370 errors
: [expectedNoSpacingError
]
374 output
: "while(a) {}",
375 errors
: [expectedSpacingError
]
379 output
: "while(a){}",
381 errors
: [expectedNoSpacingError
]
385 output
: "while(a) {}",
386 options
: keywordOnlyArgs
,
387 errors
: [expectedSpacingError
]
391 output
: "while(a){}",
392 options
: functionsOnlyArgs
,
393 errors
: [expectedNoSpacingError
]
396 code
: "while(a){ function a(){} }",
397 output
: "while(a){ function a() {} }",
398 options
: functionsOnlyArgs
,
399 errors
: [expectedSpacingError
]
402 code
: "while(a) { function a() {} }",
403 output
: "while(a) { function a(){} }",
404 options
: keywordOnlyArgs
,
405 errors
: [expectedNoSpacingError
]
408 code
: "export function a() { if(b) {} }",
409 output
: "export function a() { if(b){} }",
410 options
: functionsOnlyArgs
,
411 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" },
412 errors
: [expectedNoSpacingError
]
415 code
: "export function a(){ if(b){} }",
416 output
: "export function a(){ if(b) {} }",
417 options
: keywordOnlyArgs
,
418 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" },
419 errors
: [expectedSpacingError
]
422 code
: "export function a(){}",
423 output
: "export function a() {}",
424 options
: functionsOnlyArgs
,
425 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" },
426 errors
: [expectedSpacingError
]
429 code
: "export default function (a) {}",
430 output
: "export default function (a){}",
431 options
: keywordOnlyArgs
,
432 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" },
433 errors
: [expectedNoSpacingError
]
436 code
: "export function a() {}",
437 output
: "export function a(){}",
438 options
: keywordOnlyArgs
,
439 parserOptions
: { ecmaVersion
: 6, sourceType
: "module" },
440 errors
: [expectedNoSpacingError
]
443 code
: "class test{}",
444 output
: "class test {}",
445 parserOptions
: { ecmaVersion
: 6 },
446 errors
: [expectedSpacingError
]
449 code
: "class test{}",
450 output
: "class test {}",
451 options
: classesOnlyArgs
,
452 parserOptions
: { ecmaVersion
: 6 },
453 errors
: [expectedSpacingError
]
456 code
: "class test{ constructor(){} }",
457 output
: "class test{ constructor() {} }",
458 options
: functionsOnlyArgs
,
459 parserOptions
: { ecmaVersion
: 6 },
460 errors
: [expectedSpacingError
]
463 code
: "class test { constructor() {} }",
464 output
: "class test { constructor(){} }",
465 options
: classesOnlyArgs
,
466 parserOptions
: { ecmaVersion
: 6 },
467 errors
: [expectedNoSpacingError
]
470 code
: "class test {}",
471 output
: "class test{}",
472 options
: functionsOnlyArgs
,
473 parserOptions
: { ecmaVersion
: 6 },
474 errors
: [expectedNoSpacingError
]
477 code
: "class test {}",
478 output
: "class test{}",
480 parserOptions
: { ecmaVersion
: 6 },
481 errors
: [expectedNoSpacingError
]
484 code
: "if(a){ function a(){} }",
485 output
: "if(a){ function a() {} }",
486 options
: functionsAlwaysOthersOffArgs
,
487 errors
: [expectedSpacingError
]
490 code
: "if(a) { function a(){} }",
491 output
: "if(a) { function a() {} }",
492 options
: functionsAlwaysOthersOffArgs
,
493 errors
: [expectedSpacingError
]
496 code
: "if(a){ function a(){} }",
497 output
: "if(a) { function a(){} }",
498 options
: keywordAlwaysOthersOffArgs
,
499 errors
: [expectedSpacingError
]
502 code
: "if(a){ function a() {} }",
503 output
: "if(a) { function a() {} }",
504 options
: keywordAlwaysOthersOffArgs
,
505 errors
: [expectedSpacingError
]
508 code
: "class test{ constructor(){} }",
509 output
: "class test { constructor(){} }",
510 options
: classesAlwaysOthersOffArgs
,
511 parserOptions
: { ecmaVersion
: 6 },
512 errors
: [expectedSpacingError
]
515 code
: "class test{ constructor() {} }",
516 output
: "class test { constructor() {} }",
517 options
: classesAlwaysOthersOffArgs
,
518 parserOptions
: { ecmaVersion
: 6 },
519 errors
: [expectedSpacingError
]
522 code
: "if(a){ function a() {} }",
523 output
: "if(a){ function a(){} }",
524 options
: functionsNeverOthersOffArgs
,
525 errors
: [expectedNoSpacingError
]
528 code
: "if(a) { function a() {} }",
529 output
: "if(a) { function a(){} }",
530 options
: functionsNeverOthersOffArgs
,
531 errors
: [expectedNoSpacingError
]
534 code
: "if(a) { function a(){} }",
535 output
: "if(a){ function a(){} }",
536 options
: keywordNeverOthersOffArgs
,
537 errors
: [expectedNoSpacingError
]
540 code
: "if(a) { function a() {} }",
541 output
: "if(a){ function a() {} }",
542 options
: keywordNeverOthersOffArgs
,
543 errors
: [expectedNoSpacingError
]
546 code
: "class test { constructor(){} }",
547 output
: "class test{ constructor(){} }",
548 options
: classesNeverOthersOffArgs
,
549 parserOptions
: { ecmaVersion
: 6 },
550 errors
: [expectedNoSpacingError
]
553 code
: "class test { constructor() {} }",
554 output
: "class test{ constructor() {} }",
555 options
: classesNeverOthersOffArgs
,
556 parserOptions
: { ecmaVersion
: 6 },
557 errors
: [expectedNoSpacingError
]