@tuomashatakka/eslint-config 2.6.2 → 3.1.0

package/test/fixtures/whitespaced-multiline.valid.ts

@@ -0,0 +1,15 @@
+const fruits = [
+  'apple',
+  'banana',
+  'cherry',
+]
+
+
+const primes = [
+  2,
+  3,
+  5,
+]
+
+
+export { fruits, primes }

package/test/fixtures/whitespaced-types.valid.ts

@@ -0,0 +1,5 @@
+const shortName: string    = 'hello'
+const longNameHere: string = 'world'
+const mediumName:   number = 42
+
+export { shortName, longNameHere, mediumName }

package/test/fixtures/whitespaced.valid.ts

@@ -0,0 +1,45 @@
+import path from 'path'
+import fs from 'fs'
+
+
+const shortName = 'hello'
+
+
+const longValue = 'world'
+
+
+class DataProcessor {
+  static defaultConfig = { verbose: false }
+  private name: string
+  private data: string[]
+  constructor (name: string) {
+    this.name = name
+
+    this.data = []
+  }
+
+  process (input: string) {
+    const trimmed   = input.trim()
+
+    const processed = trimmed.toLowerCase()
+
+    this.data.push(processed)
+
+    return processed
+  }
+}
+
+
+function formatOutput (value: string): string {
+  const prefix = '[OUT]'
+  const result = `${prefix} ${value}`
+  return result
+}
+
+
+function parseInput (raw: string): string[] {
+  return raw.split('\n').filter(Boolean)
+}
+
+
+export { DataProcessor, formatOutput, parseInput }

package/test/format-cases.mjs

@@ -9,20 +9,15 @@ import { fileURLToPath } from 'url'
 const execAsync = promisify(exec)
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-/**
- * Format testing tool for ESLint configuration
- * Tests that the configuration produces consistent formatting results
- */
-
 
 class FormatTester {
   constructor () {
     this.fixturesDir = path.join(__dirname, 'fixtures')
-    this.configPath = path.join(__dirname, '../index.mjs')
-    this.results = {
+    this.configPath  = path.join(__dirname, '../index.mjs')
+    this.results     = {
       tested:    0,
       formatted: 0,
-      errors:    []
+      errors:    [],
     }
   }
 
@@ -101,7 +96,7 @@ class FormatTester {
           })
           this.results.errors.push({
             file:   filename,
-            errors: fileResult.messages.filter(m => m.severity === 2)
+            errors: fileResult.messages.filter(m => m.severity === 2),
           })
         }
         else if (warningCount > 0)
@@ -117,7 +112,7 @@ class FormatTester {
       console.log(`  ❌ Format test failed: ${error.message}`)
       this.results.errors.push({
         file:  filename,
-        error: error.message
+        error: error.message,
       })
     }
   }
@@ -158,20 +153,23 @@ name: 'test',
 value: 42,
 description: 'A test object'
 }`,
-        rules: [ '@stylistic/key-spacing' ]
+        rules: [ '@stylistic/key-spacing' ],
       },
       {
         name:   'Array formatting',
         before: `const arr = [ 1, 2, 3, 4, 5 ]`,
-        rules:  [ '@stylistic/array-bracket-spacing' ]
+        rules:  [ '@stylistic/array-bracket-spacing' ],
       },
       {
         name:   'Function spacing',
         before: `function test( param1,param2 ){
 return param1+param2
 }`,
-        rules: [ '@stylistic/space-before-function-paren', '@stylistic/space-infix-ops' ]
-      }
+        rules: [
+          '@stylistic/space-before-function-paren',
+          '@stylistic/space-infix-ops',
+        ],
+      },
     ]
 
     examples.forEach(example => {
@@ -194,4 +192,5 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     await tester.runFormatTests()
 }
 
+
 export default FormatTester

package/test/test-runner.mjs

@@ -9,32 +9,32 @@ import { fileURLToPath } from 'url'
 const execAsync = promisify(exec)
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-/**
- * Test runner for ESLint configuration
- * Validates that the config works with various code samples
- */
-
 
 class ESLintConfigTester {
   constructor () {
     this.fixturesDir = path.join(__dirname, 'fixtures')
-    this.configPath = path.join(__dirname, '../index.mjs')
-    this.results = {
+    this.configPath  = path.join(__dirname, '../index.mjs')
+    this.results     = {
       passed: 0,
       failed: 0,
-      errors: []
+      errors: [],
     }
   }
 
   async runTests () {
-    console.log('🚀 Running ESLint configuration tests...\n')
+    console.log('\n  Running ESLint configuration tests...\n')
 
     try {
       const fixtures  = await readdir(this.fixturesDir)
-      const testFiles = fixtures.filter(file => file.endsWith('.js') || file.endsWith('.tsx') || file.endsWith('.ts'))
+      const testFiles = fixtures.filter(file =>
+        file.endsWith('.js') ||
+        file.endsWith('.jsx') ||
+        file.endsWith('.ts') ||
+        file.endsWith('.tsx') ||
+        file.endsWith('.mjs'))
 
       if (testFiles.length === 0) {
-        console.log('⚠️  No test fixtures found in test/fixtures/')
+        console.log('  No test fixtures found in test/fixtures/')
         return
       }
 
@@ -44,25 +44,50 @@ class ESLintConfigTester {
       this.printSummary()
     }
     catch (error) {
-      console.error('❌ Test runner failed:', error.message)
+      console.error('  Test runner failed:', error.message)
       process.exit(1)
     }
   }
 
+
+  getFixtureMode (filename) {
+    if (filename.includes('.valid.'))
+      return 'valid'
+
+    if (filename.includes('.invalid.'))
+      return 'invalid'
+
+    return 'standard'
+  }
+
+
+  async parseExpectedWarnings (filepath) {
+    const content  = await readFile(filepath, 'utf8')
+    const lines    = content.split('\n')
+    const expected = []
+
+    for (const line of lines) {
+      const match = line.match(/(?:\/\/|{\s*\/\*)\s*expect-warning:\s*([^\s*]+)/)
+
+      if (match)
+        expected.push(match[1].trim())
+    }
+
+    return expected
+  }
+
+
   async testFile (filename) {
     const filepath = path.join(this.fixturesDir, filename)
+    const mode     = this.getFixtureMode(filename)
 
     try {
-      console.log(`📝 Testing ${filename}...`)
+      console.log(`  Testing ${filename} [${mode}]...`)
 
-      // Run ESLint on the test file
-      const { stdout, stderr } = await execAsync(
+      const { stdout } = await execAsync(
         `npx eslint "${filepath}" --config "${this.configPath}" --format json`,
-        { cwd: path.join(__dirname, '..') }
-      )
-
-      if (stderr && stderr.trim())
-        throw new Error(`ESLint stderr: ${stderr}`)
+        { cwd: path.join(__dirname, '..'), maxBuffer: 1024 * 1024 }
+      ).catch(e => ({ stdout: e.stdout, stderr: e.stderr }))
 
       const results    = JSON.parse(stdout)
       const fileResult = results[0]
@@ -72,56 +97,112 @@ class ESLintConfigTester {
 
       const errorCount   = fileResult.errorCount
       const warningCount = fileResult.warningCount
+      const messages     = fileResult.messages
 
-      if (errorCount > 0) {
-        console.log(`  ❌ ${errorCount} errors, ${warningCount} warnings`)
-        fileResult.messages.forEach(msg => {
-          if (msg.severity === 2)
-            console.log(`     Error: ${msg.message} (${msg.ruleId})`)
-        })
-        this.results.failed++
-        this.results.errors.push({
-          file:   filename,
-          errors: fileResult.messages.filter(m => m.severity === 2)
-        })
-      }
-      else {
-        console.log(`  ✅ 0 errors, ${warningCount} warnings`)
-        this.results.passed++
-      }
+      if (mode === 'valid')
+        return this.assertValid(filename, errorCount, warningCount, messages)
+
+      if (mode === 'invalid')
+        return await this.assertInvalid(filename, filepath, errorCount, warningCount, messages)
+
+      return this.assertStandard(filename, errorCount, warningCount, messages)
     }
     catch (error) {
-      console.log(`  ❌ Test failed: ${error.message}`)
+      console.log(`    FAIL: ${error.message}`)
+      this.results.failed++
+      this.results.errors.push({ file: filename, error: error.message })
+    }
+  }
+
+
+  assertStandard (filename, errorCount, warningCount, messages) {
+    if (errorCount > 0) {
+      console.log(`    FAIL — ${errorCount} errors, ${warningCount} warnings`)
+      messages.filter(m => m.severity === 2).forEach(msg =>
+        console.log(`      Error: ${msg.message} (${msg.ruleId}) [line ${msg.line}]`))
+      this.results.failed++
+      this.results.errors.push({
+        file:   filename,
+        errors: messages.filter(m => m.severity === 2),
+      })
+    }
+    else {
+      console.log(`    PASS — 0 errors, ${warningCount} warnings`)
+      this.results.passed++
+    }
+  }
+
+
+  assertValid (filename, errorCount, warningCount, messages) {
+    if (errorCount > 0 || warningCount > 0) {
+      console.log(`    FAIL — expected 0 issues, got ${errorCount} errors, ${warningCount} warnings`)
+      messages.forEach(msg =>
+        console.log(`      ${msg.severity === 2 ? 'Error' : 'Warn'}: ${msg.message} (${msg.ruleId}) [line ${msg.line}]`))
+      this.results.failed++
+      this.results.errors.push({ file: filename, errors: messages })
+    }
+    else {
+      console.log(`    PASS — clean (0 errors, 0 warnings)`)
+      this.results.passed++
+    }
+  }
+
+
+  async assertInvalid (filename, filepath, errorCount, warningCount, messages) {
+    const expected       = await this.parseExpectedWarnings(filepath)
+    const warningRuleIds = messages.filter(m => m.severity === 1).map(m => m.ruleId)
+
+    if (errorCount > 0) {
+      console.log(`    FAIL — unexpected errors found`)
+      messages.filter(m => m.severity === 2).forEach(msg =>
+        console.log(`      Error: ${msg.message} (${msg.ruleId}) [line ${msg.line}]`))
+      this.results.failed++
+      this.results.errors.push({
+        file:   filename,
+        errors: messages.filter(m => m.severity === 2),
+      })
+      return
+    }
+
+    const missing = expected.filter(rule => !warningRuleIds.includes(rule))
+
+    if (missing.length > 0) {
+      console.log(`    FAIL — expected warnings not found: ${missing.join(', ')}`)
       this.results.failed++
       this.results.errors.push({
         file:  filename,
-        error: error.message
+        error: `Missing expected warnings: ${missing.join(', ')}`,
       })
     }
+    else {
+      console.log(`    PASS — ${warningCount} expected warnings from ${expected.length} rules`)
+      this.results.passed++
+    }
   }
 
+
   printSummary () {
-    console.log('\n📊 Test Summary:')
-    console.log(`✅ Passed: ${this.results.passed}`)
-    console.log(`❌ Failed: ${this.results.failed}`)
+    console.log('\n  Test Summary:')
+    console.log(`    Passed: ${this.results.passed}`)
+    console.log(`    Failed: ${this.results.failed}`)
 
     if (this.results.failed > 0) {
-      console.log('\n🔍 Failures:')
-      this.results.errors.forEach(error => {
-        console.log(`  ${error.file}: ${error.error || 'ESLint errors'}`)
-      })
+      console.log('\n  Failures:')
+      this.results.errors.forEach(error =>
+        console.log(`    ${error.file}: ${error.error || 'ESLint errors'}`))
       process.exit(1)
     }
     else
-      console.log('\n🎉 All tests passed!')
+      console.log('\n  All tests passed!\n')
   }
 }
 
 
-// Run tests if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const tester = new ESLintConfigTester()
+
   tester.runTests()
 }
 
+
 export default ESLintConfigTester