eslint/tests/lib/rules/space-before-blocks.js

   1 /**
   2  * @fileoverview Tests for space-before-block rule.
   3  * @author Mathias Schreck <https://github.com/lo1tuma>
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Requirements
  10 //------------------------------------------------------------------------------
  11
  12 const rule = require("../../../lib/rules/space-before-blocks"),
  13     { RuleTester } = require("../../../lib/rule-tester");
  14
  15 //------------------------------------------------------------------------------
  16 // Tests
  17 //------------------------------------------------------------------------------
  18
  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" };
  32
  33 ruleTester.run("space-before-blocks", rule, {
  34     valid: [
  35         "if(a) {}",
  36         "if(a)  {}",
  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 },
  42         "if(a)\n{}",
  43         { code: "if(a)\n{}", options: neverArgs },
  44         "if(a) {}else {}",
  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 },
  50         "function a() {}",
  51         { code: "function a(){}", options: neverArgs },
  52         {
  53             code: "export default class{}",
  54             options: functionsOnlyArgs,
  55             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  56         },
  57         {
  58             code: "export default class {}",
  59             options: classesOnlyArgs,
  60             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  61         },
  62         {
  63             code: "export default function a() {}",
  64             options: functionsOnlyArgs,
  65             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  66         },
  67         {
  68             code: "export default function a(){}",
  69             options: keywordOnlyArgs,
  70             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  71         },
  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(); } }",
  79         "switch(a) { }",
  80         "switch(a)  {}",
  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 },
  86         "try {}catch(a) {}",
  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 },
  92         "for(;;) {}",
  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 },
  98         "while(a) {}",
  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 },
 104         {
 105             code: "class test { constructor() {} }",
 106             options: [{ functions: "always", keywords: "never" }],
 107             parserOptions: { ecmaVersion: 6 }
 108         },
 109         {
 110             code: "class test { constructor(){} }",
 111             options: classesOnlyArgs,
 112             parserOptions: { ecmaVersion: 6 }
 113         },
 114         {
 115             code: "class test{ constructor() {} }",
 116             options: functionsOnlyArgs,
 117             parserOptions: { ecmaVersion: 6 }
 118         },
 119         {
 120             code: "class test {}",
 121             options: classesOnlyArgs,
 122             parserOptions: { ecmaVersion: 6 }
 123         },
 124         {
 125             code: "class test{}",
 126             options: functionsOnlyArgs,
 127             parserOptions: { ecmaVersion: 6 }
 128         },
 129         {
 130             code: "class test{}",
 131             options: neverArgs,
 132             parserOptions: { ecmaVersion: 6 }
 133         },
 134         {
 135             code: "class test {}",
 136             parserOptions: { ecmaVersion: 6 }
 137         },
 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 },
 142         {
 143             code: "class test { constructor(){if(a){}} }",
 144             options: classesAlwaysOthersOffArgs,
 145             parserOptions: { ecmaVersion: 6 }
 146         },
 147         {
 148             code: "class test { constructor() {if(a){}} }",
 149             options: classesAlwaysOthersOffArgs,
 150             parserOptions: { ecmaVersion: 6 }
 151         },
 152         {
 153             code: "class test { constructor(){if(a) {}} }",
 154             options: classesAlwaysOthersOffArgs,
 155             parserOptions: { ecmaVersion: 6 }
 156         },
 157         {
 158             code: "class test { constructor() {if(a) {}} }",
 159             options: classesAlwaysOthersOffArgs,
 160             parserOptions: { ecmaVersion: 6 }
 161         },
 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 },
 166         {
 167             code: "class test{ constructor(){if(a){}} }",
 168             options: classesNeverOthersOffArgs,
 169             parserOptions: { ecmaVersion: 6 }
 170         },
 171         {
 172             code: "class test{ constructor() {if(a){}} }",
 173             options: classesNeverOthersOffArgs,
 174             parserOptions: { ecmaVersion: 6 }
 175         },
 176         {
 177             code: "class test{ constructor(){if(a) {}} }",
 178             options: classesNeverOthersOffArgs,
 179             parserOptions: { ecmaVersion: 6 }
 180         },
 181         {
 182             code: "class test{ constructor() {if(a) {}} }",
 183             options: classesNeverOthersOffArgs,
 184             parserOptions: { ecmaVersion: 6 }
 185         },
 186
 187         // https://github.com/eslint/eslint/issues/3769
 188         { code: "()=>{};", options: ["always"], parserOptions: { ecmaVersion: 6 } },
 189         { code: "() => {};", options: ["never"], parserOptions: { ecmaVersion: 6 } },
 190
 191         // https://github.com/eslint/eslint/issues/1338
 192         "if(a) {}else{}",
 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" } }
 196     ],
 197     invalid: [
 198         {
 199             code: "if(a){}",
 200             output: "if(a) {}",
 201             errors: [{ messageId: "missingSpace", line: 1, column: 6 }]
 202         },
 203         {
 204             code: "if(a){}",
 205             output: "if(a) {}",
 206             options: keywordOnlyArgs,
 207             errors: [expectedSpacingError]
 208         },
 209         {
 210             code: "if(a) {}",
 211             output: "if(a){}",
 212             options: functionsOnlyArgs,
 213             errors: [expectedNoSpacingError]
 214         },
 215         {
 216             code: "if(a) { function a() {} }",
 217             output: "if(a){ function a() {} }",
 218             options: functionsOnlyArgs,
 219             errors: [{ messageId: "unexpectedSpace", line: 1, column: 7 }]
 220         },
 221         {
 222             code: "if(a) { function a() {} }",
 223             output: "if(a) { function a(){} }",
 224             options: keywordOnlyArgs,
 225             errors: [{ messageId: "unexpectedSpace", line: 1, column: 22 }]
 226         },
 227         {
 228             code: "if(a) {}",
 229             output: "if(a){}",
 230             options: neverArgs,
 231             errors: [expectedNoSpacingError]
 232         },
 233         {
 234             code: "function a(){}",
 235             output: "function a() {}",
 236             errors: [expectedSpacingError]
 237         },
 238         {
 239             code: "function a() {}",
 240             output: "function a(){}",
 241             options: neverArgs,
 242             errors: [expectedNoSpacingError]
 243         },
 244         {
 245             code: "function a()    {}",
 246             output: "function a(){}",
 247             options: neverArgs,
 248             errors: [expectedNoSpacingError]
 249         },
 250         {
 251             code: "function a(){ if (a){} }",
 252             output: "function a() { if (a){} }",
 253             options: functionsOnlyArgs,
 254             errors: [{ messageId: "missingSpace", line: 1, column: 13 }]
 255         },
 256         {
 257             code: "function a() { if (a) {} }",
 258             output: "function a(){ if (a) {} }",
 259             options: keywordOnlyArgs,
 260             errors: [{ messageId: "unexpectedSpace", line: 1, column: 14 }]
 261         },
 262         {
 263             code: "function a(){}",
 264             output: "function a() {}",
 265             options: functionsOnlyArgs,
 266             errors: [expectedSpacingError]
 267         },
 268         {
 269             code: "function a() {}",
 270             output: "function a(){}",
 271             options: keywordOnlyArgs,
 272             errors: [expectedNoSpacingError]
 273         },
 274         {
 275             code: "switch(a){}",
 276             output: "switch(a) {}",
 277             errors: [expectedSpacingError]
 278         },
 279         {
 280             code: "switch(a) {}",
 281             output: "switch(a){}",
 282             options: neverArgs,
 283             errors: [expectedNoSpacingError]
 284         },
 285         {
 286             code: "switch(a){}",
 287             output: "switch(a) {}",
 288             options: keywordOnlyArgs,
 289             errors: [expectedSpacingError]
 290         },
 291         {
 292             code: "switch(a) {}",
 293             output: "switch(a){}",
 294             options: functionsOnlyArgs,
 295             errors: [expectedNoSpacingError]
 296         },
 297         {
 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]
 301         },
 302         {
 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(); } }",
 305             options: neverArgs,
 306             errors: [expectedNoSpacingError]
 307         },
 308         {
 309             code: "try{}catch(a){}",
 310             output: "try{}catch(a) {}",
 311             errors: [expectedSpacingError]
 312         },
 313         {
 314             code: "try {}catch(a) {}",
 315             output: "try {}catch(a){}",
 316             options: neverArgs,
 317             errors: [expectedNoSpacingError]
 318         },
 319         {
 320             code: "try {} catch(a){}",
 321             output: "try {} catch(a) {}",
 322             options: keywordOnlyArgs,
 323             errors: [expectedSpacingError]
 324         },
 325         {
 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 }]
 330         },
 331         {
 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 }]
 336         },
 337         {
 338             code: "for(;;){}",
 339             output: "for(;;) {}",
 340             errors: [expectedSpacingError]
 341         },
 342         {
 343             code: "for(;;) {}",
 344             output: "for(;;){}",
 345             options: neverArgs,
 346             errors: [expectedNoSpacingError]
 347         },
 348         {
 349             code: "for(;;){}",
 350             output: "for(;;) {}",
 351             options: keywordOnlyArgs,
 352             errors: [expectedSpacingError]
 353         },
 354         {
 355             code: "for(;;) {}",
 356             output: "for(;;){}",
 357             options: functionsOnlyArgs,
 358             errors: [expectedNoSpacingError]
 359         },
 360         {
 361             code: "for(;;){ function a(){} }",
 362             output: "for(;;){ function a() {} }",
 363             options: functionsOnlyArgs,
 364             errors: [expectedSpacingError]
 365         },
 366         {
 367             code: "for(;;) { function a() {} }",
 368             output: "for(;;) { function a(){} }",
 369             options: keywordOnlyArgs,
 370             errors: [expectedNoSpacingError]
 371         },
 372         {
 373             code: "while(a){}",
 374             output: "while(a) {}",
 375             errors: [expectedSpacingError]
 376         },
 377         {
 378             code: "while(a) {}",
 379             output: "while(a){}",
 380             options: neverArgs,
 381             errors: [expectedNoSpacingError]
 382         },
 383         {
 384             code: "while(a){}",
 385             output: "while(a) {}",
 386             options: keywordOnlyArgs,
 387             errors: [expectedSpacingError]
 388         },
 389         {
 390             code: "while(a) {}",
 391             output: "while(a){}",
 392             options: functionsOnlyArgs,
 393             errors: [expectedNoSpacingError]
 394         },
 395         {
 396             code: "while(a){ function a(){} }",
 397             output: "while(a){ function a() {} }",
 398             options: functionsOnlyArgs,
 399             errors: [expectedSpacingError]
 400         },
 401         {
 402             code: "while(a) { function a() {} }",
 403             output: "while(a) { function a(){} }",
 404             options: keywordOnlyArgs,
 405             errors: [expectedNoSpacingError]
 406         },
 407         {
 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]
 413         },
 414         {
 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]
 420         },
 421         {
 422             code: "export function a(){}",
 423             output: "export function a() {}",
 424             options: functionsOnlyArgs,
 425             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 426             errors: [expectedSpacingError]
 427         },
 428         {
 429             code: "export default function (a) {}",
 430             output: "export default function (a){}",
 431             options: keywordOnlyArgs,
 432             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 433             errors: [expectedNoSpacingError]
 434         },
 435         {
 436             code: "export function a() {}",
 437             output: "export function a(){}",
 438             options: keywordOnlyArgs,
 439             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 440             errors: [expectedNoSpacingError]
 441         },
 442         {
 443             code: "class test{}",
 444             output: "class test {}",
 445             parserOptions: { ecmaVersion: 6 },
 446             errors: [expectedSpacingError]
 447         },
 448         {
 449             code: "class test{}",
 450             output: "class test {}",
 451             options: classesOnlyArgs,
 452             parserOptions: { ecmaVersion: 6 },
 453             errors: [expectedSpacingError]
 454         },
 455         {
 456             code: "class test{ constructor(){} }",
 457             output: "class test{ constructor() {} }",
 458             options: functionsOnlyArgs,
 459             parserOptions: { ecmaVersion: 6 },
 460             errors: [expectedSpacingError]
 461         },
 462         {
 463             code: "class test { constructor() {} }",
 464             output: "class test { constructor(){} }",
 465             options: classesOnlyArgs,
 466             parserOptions: { ecmaVersion: 6 },
 467             errors: [expectedNoSpacingError]
 468         },
 469         {
 470             code: "class test {}",
 471             output: "class test{}",
 472             options: functionsOnlyArgs,
 473             parserOptions: { ecmaVersion: 6 },
 474             errors: [expectedNoSpacingError]
 475         },
 476         {
 477             code: "class test {}",
 478             output: "class test{}",
 479             options: neverArgs,
 480             parserOptions: { ecmaVersion: 6 },
 481             errors: [expectedNoSpacingError]
 482         },
 483         {
 484             code: "if(a){ function a(){} }",
 485             output: "if(a){ function a() {} }",
 486             options: functionsAlwaysOthersOffArgs,
 487             errors: [expectedSpacingError]
 488         },
 489         {
 490             code: "if(a) { function a(){} }",
 491             output: "if(a) { function a() {} }",
 492             options: functionsAlwaysOthersOffArgs,
 493             errors: [expectedSpacingError]
 494         },
 495         {
 496             code: "if(a){ function a(){} }",
 497             output: "if(a) { function a(){} }",
 498             options: keywordAlwaysOthersOffArgs,
 499             errors: [expectedSpacingError]
 500         },
 501         {
 502             code: "if(a){ function a() {} }",
 503             output: "if(a) { function a() {} }",
 504             options: keywordAlwaysOthersOffArgs,
 505             errors: [expectedSpacingError]
 506         },
 507         {
 508             code: "class test{ constructor(){} }",
 509             output: "class test { constructor(){} }",
 510             options: classesAlwaysOthersOffArgs,
 511             parserOptions: { ecmaVersion: 6 },
 512             errors: [expectedSpacingError]
 513         },
 514         {
 515             code: "class test{ constructor() {} }",
 516             output: "class test { constructor() {} }",
 517             options: classesAlwaysOthersOffArgs,
 518             parserOptions: { ecmaVersion: 6 },
 519             errors: [expectedSpacingError]
 520         },
 521         {
 522             code: "if(a){ function a() {} }",
 523             output: "if(a){ function a(){} }",
 524             options: functionsNeverOthersOffArgs,
 525             errors: [expectedNoSpacingError]
 526         },
 527         {
 528             code: "if(a) { function a() {} }",
 529             output: "if(a) { function a(){} }",
 530             options: functionsNeverOthersOffArgs,
 531             errors: [expectedNoSpacingError]
 532         },
 533         {
 534             code: "if(a) { function a(){} }",
 535             output: "if(a){ function a(){} }",
 536             options: keywordNeverOthersOffArgs,
 537             errors: [expectedNoSpacingError]
 538         },
 539         {
 540             code: "if(a) { function a() {} }",
 541             output: "if(a){ function a() {} }",
 542             options: keywordNeverOthersOffArgs,
 543             errors: [expectedNoSpacingError]
 544         },
 545         {
 546             code: "class test { constructor(){} }",
 547             output: "class test{ constructor(){} }",
 548             options: classesNeverOthersOffArgs,
 549             parserOptions: { ecmaVersion: 6 },
 550             errors: [expectedNoSpacingError]
 551         },
 552         {
 553             code: "class test { constructor() {} }",
 554             output: "class test{ constructor() {} }",
 555             options: classesNeverOthersOffArgs,
 556             parserOptions: { ecmaVersion: 6 },
 557             errors: [expectedNoSpacingError]
 558         }
 559     ]
 560 });