fix: added ci

.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: ci
+on:
+  push:
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        node-version: [17]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: pnpm/[email protected]
+      with:
+        version: 7.0.0-rc.2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'pnpm'
+    - name: install
+      run: pnpm install
+    - name: test 
+      run: pnpm test

README.md

@@ -1,5 +1,7 @@
 ## eslint-plugin-vitest
 
+> Disclaimer: This package is very experimental
+
 ![npm](https://img.shields.io/npm/v/eslint-plugin-vitest)
 
 Eslint plugin for vitest

src/index.ts

@@ -1,9 +1,17 @@
-import lowerCaseTitle from "./rules/lower-case-title";
-import noSkippedTests from "./rules/no-skipped-tests";
-
-export default {
-    rules: {
-        'no-skip-test': noSkippedTests,
-        'lower-case-title': lowerCaseTitle
-    }
-}
+import { readdirSync } from "fs";
+import { dirname, join, parse } from "path";
+import { fileURLToPath } from "url";
+
+const rulesDir = dirname(fileURLToPath(import.meta.url));
+
+console.log({ rulesDir })
+
+const values = readdirSync(rulesDir)
+    .map(rule => parse(rule).name)
+    .reduce((allRules, ruleName) => ({
+        ...allRules,
+        [ruleName]: import(join(rulesDir, ruleName)),
+    }), {})
+
+
+console.log({ values })

src/rules/assertion-type.ts

@@ -0,0 +1,62 @@
+import { createEslintRule } from "../utils";
+
+export const RULE_NAME = 'assertion-type';
+export type MessageIds = 'assertionType';
+export type Options = [
+    {
+        type: "jest" | "chai",
+    }
+];
+export default createEslintRule<Options, MessageIds>({
+    name: RULE_NAME,
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Enforce assertion type",
+            recommended: "error",
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: ['jest', 'chai'],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            assertionType: "Assertion type should be {{type}}.",
+        },
+    },
+    defaultOptions: [
+        {
+            type: "jest",
+        },
+    ],
+    create(context) {
+        const { type } = context.options[0];
+        const assertionType = type === "jest" ? "expect" : "assert";
+        return {
+            ExpressionStatement(node) {
+                if (node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier") {
+                    if (node.expression.callee.name === assertionType) {
+                        const { arguments: args } = node.expression
+                        if (args[0].type === "Identifier" && args[0].name !== "t") {
+                            context.report({
+                                node,
+                                messageId: 'assertionType',
+                                data: {
+                                    type,
+                                },
+                            })
+                        }
+                    }
+                }
+            }
+        }
+    }
+});

tests/assertion-type.test.ts

@@ -0,0 +1,23 @@
+import { RuleTester } from "@typescript-eslint/utils/dist/ts-eslint"
+import { it } from "vitest"
+import { RULE_NAME } from "../src/rules/assertion-type"
+
+
+const valid = [`it.each()`]
+const invalids = []
+
+
+it(RULE_NAME, () => {
+    const rule_tester: RuleTester = new RuleTester({
+        parser: require.resolve("@typescript-eslint/parser")
+    })
+
+    // rule_tester.run(RULE_NAME, rule, {
+    //     valid,
+    //     invalid: invalids.map(i => ({
+    //         code: i,
+    //         output: i,
+    //         errors: [{ messageId: "lowerCaseTitle" }],
+    //     })),
+    // })
+})

src/rules/lower-case-title.test.ts → tests/lower-case-title.test.ts

@@ -1,6 +1,6 @@
 import { RuleTester } from "@typescript-eslint/utils/dist/ts-eslint"
 import { it } from "vitest"
-import rule, { RULE_NAME } from "./lower-case-title"
+import rule, { RULE_NAME } from "../src/rules/lower-case-title"
 
 
 

src/rules/no-conditional-in-tests.test.ts → tests/no-conditional-in-tests.test.ts

@@ -1,6 +1,6 @@
 import { RuleTester } from "@typescript-eslint/utils/dist/ts-eslint"
 import { it } from "vitest"
-import rule, { RULE_NAME } from "./no-conditional-in-tests"
+import rule, { RULE_NAME } from "../src/rules/no-conditional-in-tests"
 
 const invalids = [
   `describe('my tests', () => {

src/rules/no-skipped-tests.test.ts → tests/no-skipped-tests.test.ts

@@ -1,6 +1,6 @@
 import { RuleTester } from "@typescript-eslint/utils/dist/ts-eslint"
 import { it } from "vitest"
-import rule, { RULE_NAME } from "./no-skipped-tests"
+import rule, { RULE_NAME } from "../src/rules/no-skipped-tests"
 
 const valids = [
     `it("test", () => {});`,