@definitelytyped/eslint-plugin 0.0.166-next.4

package/test/no-any-union.test.ts

@@ -0,0 +1,22 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noAnyUnion from "../src/rules/no-any-union";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-any-union", noAnyUnion, {
+  invalid: [
+    {
+      code: `export const y: string | any;`,
+      errors: [
+        {
+          line: 1,
+          messageId: "anyUnion",
+        },
+      ],
+    },
+  ],
+  valid: [`export const x: any;`],
+});

package/test/no-bad-reference.test.ts

@@ -0,0 +1,66 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noBadReference from "../src/rules/no-bad-reference";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-bad-reference", noBadReference, {
+  invalid: [
+    {
+      code: `/// <reference path="../other" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 28,
+          line: 1,
+          messageId: "referencePathTest",
+        },
+      ],
+      filename: "types.ts",
+    },
+    {
+      code: `/// <reference path="other" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 25,
+          line: 1,
+          messageId: "referencePathTest",
+        },
+      ],
+      filename: "types.ts",
+    },
+    {
+      code: `/// <reference path="../other" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 28,
+          line: 1,
+          messageId: "referencePathPackage",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+  ],
+  valid: [
+    ``,
+    `// unrelated comment`,
+    `/// similar (reference path) comment`,
+    {
+      code: `/// <reference path="other" />`,
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="./other" />`,
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="other" />
+/// <reference path="other2" />`,
+      filename: "types.d.ts",
+    },
+  ],
+});

package/test/no-const-enum.test.ts

@@ -0,0 +1,22 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noConstEnum from "../src/rules/no-const-enum";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-const-enum", noConstEnum, {
+  invalid: [
+    {
+      code: ` const enum E { } `,
+      errors: [
+        {
+          line: 1,
+          messageId: "constEnum",
+        },
+      ],
+    },
+  ],
+  valid: [` enum F {}`],
+});

package/test/no-dead-reference.test.ts

@@ -0,0 +1,66 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noDeadReference from "../src/rules/no-dead-reference";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-dead-reference", noDeadReference, {
+  invalid: [
+    {
+      code: `
+export class C { }
+/// <reference types="terms" />
+`,
+      errors: [
+        {
+          line: 3,
+          messageId: "referenceAtTop",
+        },
+      ],
+    },
+    {
+      code: `
+export class C { }
+/// <reference types="terms" />
+/// <reference types="multiple" />
+`,
+      errors: [
+        {
+          line: 3,
+          messageId: "referenceAtTop",
+        },
+        {
+          line: 4,
+          messageId: "referenceAtTop",
+        },
+      ],
+    },
+    {
+      code: `
+export class C { }
+/// <reference types="terms" />
+export class D { }
+/// <reference types="multiple" />
+export class E { }
+`,
+      errors: [
+        {
+          line: 3,
+          messageId: "referenceAtTop",
+        },
+        {
+          line: 5,
+          messageId: "referenceAtTop",
+        },
+      ],
+    },
+  ],
+  valid: [
+    `
+/// <reference types="tones" />
+export class K {}
+`,
+  ],
+});

package/test/no-declare-current-package.test.ts

@@ -0,0 +1,61 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noDeclareCurrentPackage from "../src/rules/no-declare-current-package";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2018,
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.no-declare-current-package.json",
+  },
+});
+
+ruleTester.run("@definitelytyped/no-declare-current-package", noDeclareCurrentPackage, {
+  invalid: [
+    {
+      filename: "index.d.ts",
+      code: `module "test" { }`,
+      errors: [
+        {
+          line: 1,
+          messageId: "noDeclareCurrentPackage",
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      filename: "index.d.ts",
+      code: `module "foo" { }
+module "foo/bar/baz" { }
+`,
+    },
+  ],
+});
+// needed because you can only test one non-file.ts file per tsconfig
+// (and tsconfig is required for typed-based rules)
+const ruleTester2 = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2018,
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.no-declare-current-package2.json",
+  },
+});
+
+ruleTester2.run("no-declare-current-package", noDeclareCurrentPackage, {
+  invalid: [
+    {
+      filename: "deep/import.d.ts",
+      code: `module "test/deep/import" { }`,
+      errors: [
+        {
+          line: 1,
+          messageId: "noDeclareCurrentPackage",
+        },
+      ],
+    },
+  ],
+  valid: [],
+});

package/test/no-import-default-of-export-equals.test.ts

@@ -0,0 +1,49 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noImportDefaultOfExportEquals from "../src/rules/no-import-default-of-export-equals";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2018,
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.no-import-default-of-export-equals.json",
+  },
+});
+
+ruleTester.run("@definitelytyped/no-import-default-of-export-equals", noImportDefaultOfExportEquals, {
+  invalid: [
+    {
+      filename: "index.d.ts",
+      code: `declare module "a" {
+    interface I {}
+    export = I;
+}
+
+declare module "b" {
+import a from "a";
+}`,
+      errors: [
+        {
+          line: 7,
+          messageId: "noImportDefaultOfExportEquals",
+          data: { moduleName: "a", importName: "a" },
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      filename: "index.d.ts",
+      code: `declare module "a" {
+    interface I {}
+    export default I;
+}
+
+declare module "b" {
+    import a from "a";
+}
+`,
+    },
+  ],
+});

package/test/no-self-import.test.ts

@@ -0,0 +1,47 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import path from "path";
+
+import * as dtHeader from "../src/rules/no-self-import";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.no-self-import.json",
+  },
+});
+
+ruleTester.run("@definitelytyped/no-self-import", dtHeader, {
+  invalid: [
+    {
+      code: `import myself from "this-package";`,
+      errors: [
+        {
+          line: 1,
+          messageId: "useRelativeImport",
+        },
+      ],
+      filename: "this-package/index.d.ts",
+    },
+    {
+      code: `import abc from "this-package/abc.d.ts";`,
+      errors: [
+        {
+          line: 1,
+          messageId: "useRelativeImport",
+        },
+      ],
+      filename: "this-package/index.d.ts",
+    },
+  ],
+  valid: [
+    {
+      code: `import other from "other-package";`,
+      filename: "this-package/index.d.ts",
+    },
+    {
+      code: `import other from "other-package/this-package";`,
+      filename: "this-package/index.d.ts",
+    },
+  ],
+});

package/test/no-single-element-tuple-type.test.ts

@@ -0,0 +1,28 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noDeclareCurrentPackage from "../src/rules/no-single-element-tuple-type";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-single-element-tuple-type", noDeclareCurrentPackage, {
+  invalid: [
+    {
+      code: `type Test<T> = [T];`,
+      errors: [
+        {
+          line: 1,
+          messageId: "singleElementTupleType",
+        },
+      ],
+    },
+  ],
+  valid: [
+    `type Test = number[];`,
+    `type Test<T> = T;`,
+    `type Test<T> = T[];`,
+    `type Test<T> = [T, number];`,
+    `type Test<T> = [T, T];`,
+  ],
+});

package/test/no-unnecessary-generics.test.ts

@@ -0,0 +1,152 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as rule from "../src/rules/no-unnecessary-generics";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parserOptions: {
+    ecmaVersion: 2018,
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.json",
+  },
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-unnecessary-generics", rule, {
+  invalid: [
+    {
+      code: `
+const f2 = <T>(): T => {};
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 19,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+class C {
+  constructor<T>(x: T) {}
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 21,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+function f<T>(): T { }
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 18,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+function f<T>(x: { T: number }): void;
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 12,
+          messageId: "never",
+        },
+      ],
+    },
+    {
+      code: `
+function f<T, U extends T>(u: U): U;
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 25,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+const f = function<T>(): T {};
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 26,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+interface I {
+  <T>(value: T): void;
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 14,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+interface I {
+  m<T>(x: T): void;
+}
+  `,
+      errors: [
+        {
+          line: 3,
+          column: 11,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+type Fn = <T>() => T;
+  `,
+      errors: [
+        {
+          line: 2,
+          column: 20,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+type Ctr = new<T>() => T;
+  `,
+      errors: [
+        {
+          line: 2,
+          column: 24,
+          messageId: "sole",
+        },
+      ],
+    },
+  ],
+  valid: [
+    `function example(a: string): string;`,
+    `function example<T>(a: T): T;`,
+    `function example<T>(a: T[]): T;`,
+    `function example<T>(a: Set<T>): T;`,
+    `function example<T>(a: Set<T>, b: T[]): void;`,
+    `function example<T>(a: Map<T, T>): void;`,
+    `function example<T, U extends T>(t: T, u: U): U;`,
+  ],
+});

package/test/no-useless-files.test.ts

@@ -0,0 +1,42 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as noUselessFiles from "../src/rules/no-useless-files";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-useless-files", noUselessFiles, {
+  invalid: [
+    {
+      code: `// I am useless`,
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: "noContent",
+        },
+      ],
+    },
+    {
+      code: ``,
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: "noContent",
+        },
+      ],
+    },
+    {
+      code: `/// <reference lib="baz" />`,
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: "noContent",
+        },
+      ],
+    },
+  ],
+  valid: [`export default "I am useful";`, `/// <reference path="foo" />`, `/// <reference types="bar" />`],
+});

package/test/prefer-declare-function.test.ts

@@ -0,0 +1,66 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as preferDeclareFunction from "../src/rules/prefer-declare-function";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/prefer-declare-function", preferDeclareFunction, {
+  invalid: [
+    {
+      filename: "index.d.ts",
+      code: `export const example: () => void;`,
+      errors: [
+        {
+          column: 14,
+          endColumn: 33,
+          line: 1,
+          messageId: "variableFunction",
+        },
+      ],
+    },
+    {
+      filename: "index.d.ts",
+      code: `
+        namespace N {
+            export const example: () => void;
+        }
+`,
+      errors: [
+        {
+          column: 26,
+          endColumn: 45,
+          line: 3,
+          messageId: "variableFunction",
+        },
+      ],
+    },
+    {
+      filename: "index.d.ts",
+      code: `
+        namespace N {
+            const example: () => void;
+        }
+`,
+      errors: [
+        {
+          column: 19,
+          endColumn: 38,
+          line: 3,
+          messageId: "variableFunction",
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      filename: "index.d.ts",
+      code: `function example(): void`,
+    },
+    {
+      filename: "test.ts",
+      code: `export const example: () => void;`,
+    },
+  ],
+});

package/test/redundant-undefined.test.ts

@@ -0,0 +1,39 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as redundantUndefined from "../src/rules/redundant-undefined";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/redundant-undefined", redundantUndefined, {
+  invalid: [
+    {
+      code: `function f(s?: string | undefined): void {}`,
+      errors: [
+        {
+          line: 1,
+          messageId: "redundantUndefined",
+        },
+      ],
+    },
+    {
+      code: `function f([a, b]?: [number, number] | undefined): void {}`,
+      errors: [
+        {
+          line: 1,
+          messageId: "redundantUndefined",
+        },
+      ],
+    },
+  ],
+  valid: [
+    `
+interface I {
+    ok?: string | undefined;
+    s?: string;
+    almost?: number | string;
+}
+`,
+  ],
+});