@toptal/davinci-syntax 16.2.2-alpha-fix-package-version-test.29 → 16.2.2

package/src/__tests__/eslint.test.ts

@@ -0,0 +1,359 @@
+/* eslint-disable max-lines */
+import path from 'path'
+import { ESLint, Linter } from 'eslint'
+import json5 from 'json5'
+
+const getConfig = () => {
+  const pathToEslintrc = path.join(__dirname, '../../src/configs/.eslintrc.js')
+
+  return new ESLint({
+    useEslintrc: false, // don't use any other eslintrc files (higher in the folder tree)
+    overrideConfigFile: pathToEslintrc, // use this exact eslintrc file
+  }).calculateConfigForFile(pathToEslintrc)
+}
+
+// Eslint config file snapshot file to prevent unexpected updates
+describe('eslint config', () => {
+  let fileConfig: Record<string, unknown>
+
+  beforeAll(async () => {
+    fileConfig = await getConfig()
+  })
+
+  it('verifies eslint rules are not updated silently', () => {
+    const serializedRules = json5.stringify(fileConfig.rules, null, 2)
+
+    expect(serializedRules).toMatchSnapshot()
+  })
+})
+
+/* eslint-disable max-statements */
+/* eslint-disable max-lines-per-function */
+// Testing basic rules with the davinci eslint
+describe('eslint rules', () => {
+  let engine: ESLint
+
+  beforeAll(async () => {
+    engine = new ESLint({ baseConfig: await getConfig() })
+  })
+
+  const findMessage = (ruleId: string, results: ESLint.LintResult[]) => {
+    return results.reduce<Linter.LintMessage | undefined>(
+      (_, result) => result.messages.find(message => message.ruleId === ruleId),
+      undefined
+    )
+  }
+
+  interface TestRulesArgs {
+    ruleId: string
+    validCases?: string[]
+    invalidCases?: string[]
+  }
+
+  const testRule = ({
+    ruleId,
+    validCases = [],
+    invalidCases = [],
+  }: TestRulesArgs) => {
+    it(`verifies that ${ruleId} works`, async () => {
+      for (const validText of validCases) {
+        const results = await engine.lintText(validText)
+
+        expect(findMessage(ruleId, results)).toBeUndefined()
+      }
+
+      for (const invalidText of invalidCases) {
+        const results = await engine.lintText(invalidText)
+
+        expect(findMessage(ruleId, results)).toBeDefined()
+      }
+    })
+  }
+
+  testRule({
+    ruleId: '@typescript-eslint/space-before-function-paren',
+    invalidCases: [
+      'function withoutSpace (x) {}',
+      'var anonymousWithoutSpace = function() {};',
+    ],
+    validCases: [
+      'function withoutSpace(x) {}',
+      'var anonymousWithoutSpace = function () {};',
+      'var anonymousWithoutSpace = function <T>() {};',
+    ],
+  })
+
+  testRule({
+    ruleId: 'padding-line-between-statements',
+    invalidCases: [
+      `
+        function foo() {
+          bar();
+          return;
+        }
+        `,
+    ],
+    validCases: [
+      `
+        function foo() {
+          bar();
+
+          return;
+        }
+        `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'prefer-const',
+    invalidCases: [
+      `
+        let a = 3
+        console.log(a)
+        `,
+    ],
+    validCases: [
+      `
+        let a = 3
+        a = 0
+        console.log(a)
+        `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'id-length',
+    invalidCases: ['const x = 5'],
+    validCases: [
+      'var ok = 5',
+      'const foo = { ok: 1 }',
+      `const _ = 'unused'`,
+      `
+        try {
+          throw new Error();
+        } catch (e) {
+          console.error(e)
+        }
+        `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'quotes',
+    invalidCases: ['const foo = "bar"'],
+    validCases: [`const foo = 'bar'`],
+  })
+
+  testRule({
+    ruleId: 'no-else-return',
+    invalidCases: [
+      `
+      function foo() {
+        if (x) {
+            return y
+        } else {
+            return z
+        }
+      }
+      `,
+    ],
+    validCases: [
+      `
+      function foo() {
+        if (x) {
+            return y
+        }
+
+        return z
+      }
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'import/no-extraneous-dependencies',
+    invalidCases: [`import { ESLint } from 'eslint'`],
+    validCases: [`import fs from 'fs'`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/array-type',
+    invalidCases: [`const foo: Array<string> = ['a', 'b']`],
+    validCases: [`const foo: string[] = ['a', 'b']`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/array-type',
+    invalidCases: [`const foo: Array<string> = ['a', 'b']`],
+    validCases: [`const foo: string[] = ['a', 'b']`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/array-type',
+    invalidCases: [`const foo: Array<string> = ['a', 'b']`],
+    validCases: [`const foo: string[] = ['a', 'b']`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/explicit-function-return-type',
+    validCases: [`const foo = (): number => 1`, `const foo = () => 1`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/no-use-before-define',
+    invalidCases: [
+      `
+      foo()
+
+      const foo = () => {}
+      `,
+    ],
+    validCases: [
+      `
+      const foo = () => {}
+      
+      foo()
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/no-unused-vars',
+    invalidCases: ['const foo = 1'],
+    validCases: [
+      `
+      const foo = 1
+      
+      console.log(foo)
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/func-call-spacing',
+    invalidCases: ['foo ()', 'foo<T> ()'],
+    validCases: ['foo()', 'foo<T>()'],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/no-unused-expressions',
+    invalidCases: ['if (0) null'],
+    validCases: ['if (0) return null'],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/ban-types',
+    invalidCases: [`const foo: String = 'foo'`, 'const foo: Number = 1'],
+    validCases: [
+      'const foo: Function = () => 1',
+      'const foo: object = {}',
+      'const foo: {} = {}',
+    ],
+  })
+
+  testRule({
+    ruleId: 'func-style',
+    invalidCases: ['function foo() {}'],
+    validCases: ['const foo = function() {}'],
+  })
+
+  testRule({
+    ruleId: 'curly',
+    invalidCases: ['if (foo) foo++'],
+    validCases: ['if (foo) { foo++ }'],
+  })
+
+  testRule({
+    ruleId: 'todo-plz/ticket-ref',
+    invalidCases: [
+      '// TODO:',
+      '// TODO: lorem',
+      '// TODO :',
+      '// TODO: [FX-]',
+      '// TODO: [-000]',
+      '// TODO: [-AAA]',
+      '// TODO [FX-000]',
+      '// TODO:[FX-000]',
+      '// TODO: FX-000',
+      '// TODO: lorem FX-000 ipsum',
+      `/**
+        * TODO:
+        */`,
+      `/**
+        * TODO: lorem
+        */`,
+    ],
+    validCases: [
+      '// TODO: [FX-000]',
+      '// TODO: [SPC-000]',
+      '// TODO: [FX-000] [SPC-000]',
+      '// TODO: [FX-000], [SPC-000]',
+      '// TODO: [FX-000], [SPC-000],',
+      '// TODO: [FX-000] [SPC-000],',
+      '// TODO: lorem [FX-000] [SPC-000],',
+      '// TODO: [FX-000] [SPC-000], lorem',
+      `/**
+        * TODO: [FX-000] lorem
+        */`,
+      `/**
+        * TODO: lorem [FX-000] ipsum
+        */`,
+      `/**
+        * TODO: lorem ipsum
+        * lorem [FX-000]
+        */`,
+      `/**
+        * TODO: lorem ipsum
+        * [FX-000]
+        */`,
+    ],
+  })
+
+  testRule({
+    ruleId: 'unused-imports/no-unused-imports',
+    invalidCases: [
+      `import { unusedImport } from 'something'`,
+      `import { unusedImport1, unusedImport2 } from 'something'`,
+    ],
+    validCases: [
+      `import { something } from 'something'
+      const c = something.usintThis()
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'import/no-duplicates',
+    invalidCases: [
+      `import { component1 } from 'module1';
+       import { component2 } from 'module1';`,
+      `import component1 from 'module1';
+       import { component2 } from 'module1';`,
+    ],
+    validCases: [
+      `import { component1, component2 } from 'module1';
+       import component3 from 'module2';`,
+      `import { component1 } from 'module';
+       import * as component2 from 'module';`,
+      `import { component1 } from 'module';
+       export { component2 } from 'module';`,
+      `import { component1, component2 } from 'module';
+       export * as component3 from 'module';
+       export * from 'module';`,
+      `import component1, * as component2 from './module'
+       import type componentType1 from './module'`,
+    ],
+  })
+
+  testRule({
+    ruleId: 'no-restricted-imports',
+    invalidCases: [
+      `import { palette } from '@toptal/picasso-provider';`,
+      `import { 
+        palette
+      } from '@toptal/picasso-provider';`,
+      `import Picasso, { useScreenSize, palette } from '@toptal/picasso-provider';`,
+    ],
+    validCases: [`import { palette } from '@toptal/picasso-utils';`],
+  })
+})

package/src/__tests__/no-relative-packages.test.js

@@ -0,0 +1,107 @@
+import { RuleTester } from 'eslint'
+import path from 'path'
+import rule from 'eslint-plugin-import/lib/rules/no-relative-packages'
+
+const testFilePath = relativePath =>
+  path.join(__dirname, '/eslint-package-structure', relativePath)
+
+const FILENAME = testFilePath('foo.js')
+
+const testRule = options => ({
+  filename: FILENAME,
+  parserOptions: {
+    sourceType: 'module',
+    ecmaVersion: 9,
+    ...options.parserOptions,
+  },
+  ...options,
+})
+
+const ruleTester = new RuleTester()
+
+ruleTester.run('no-relative-packages', rule, {
+  valid: [
+    testRule({
+      code: 'import foo from "./index.js"',
+      filename: testFilePath('./package/index.js'),
+    }),
+    /**
+     * Unfortunately, this case is considered valid for the rule,
+     * but we cannot influence this. This case should be considered invalid.
+     *
+     * testRule({
+     *  code: 'import bar from "../bar"',
+     *  filename: testFilePath('./package/index.js')
+     * }),
+     */
+    testRule({
+      code: 'import { foo } from "a"',
+      filename: testFilePath('./package-named/index.js'),
+    }),
+    testRule({
+      code: 'const bar = require("../bar.js")',
+      filename: testFilePath('./package/index.js'),
+    }),
+    testRule({
+      code: 'import "package"',
+      filename: testFilePath('./package/index.js'),
+    }),
+    testRule({
+      code: 'require("../bar.js")',
+      filename: testFilePath('./package/index.js'),
+    }),
+  ],
+  invalid: [
+    testRule({
+      code: 'import foo from "./package-named"',
+      filename: testFilePath('./bar.js'),
+      errors: [
+        {
+          message:
+            'Relative import from another package is not allowed. Use `package-named` instead of `./package-named`',
+          line: 1,
+          column: 17,
+        },
+      ],
+      output: 'import foo from "package-named"',
+    }),
+    testRule({
+      code: 'import foo from "../package-named"',
+      filename: testFilePath('./package/index.js'),
+      errors: [
+        {
+          message:
+            'Relative import from another package is not allowed. Use `package-named` instead of `../package-named`',
+          line: 1,
+          column: 17,
+        },
+      ],
+      output: 'import foo from "package-named"',
+    }),
+    testRule({
+      code: 'import foo from "../package-scoped"',
+      filename: testFilePath('./package/index.js'),
+      errors: [
+        {
+          message: `Relative import from another package is not allowed. Use \`@scope/package-named\` instead of \`../package-scoped\``,
+          line: 1,
+          column: 17,
+        },
+      ],
+      output: 'import foo from "@scope/package-named"',
+    }),
+    testRule({
+      code: 'import bar from "../bar"',
+      filename: testFilePath('./package-named/index.js'),
+      errors: [
+        {
+          message: `Relative import from another package is not allowed. Use \`@toptal/davinci-syntax/src/__tests__/eslint-package-structure/bar\` instead of \`../bar\``,
+          line: 1,
+          column: 17,
+        },
+      ],
+      output:
+        'import bar from "@toptal/davinci-syntax/src/__tests__/eslint-package-structure/bar"',
+    }),
+  ],
+})