rules.int.test.ts

import { cp } from 'node:fs/promises';
import path from 'node:path';
import process from 'node:process';
import { fileURLToPath } from 'node:url';
import type { MockInstance } from 'vitest';
import {
  restoreNxIgnoredFiles,
  teardownTestFolder,
} from '@code-pushup/test-utils';
import type { ESLintTarget } from '../config.js';
import type { RuleData } from './parse.js';
import { listRules } from './rules.js';

describe('listRules', () => {
  const fixturesDir = path.join(
    fileURLToPath(path.dirname(import.meta.url)),
    '..',
    '..',
    '..',
    'mocks',
    'fixtures',
  );
  const tmpDir = path.join(process.cwd(), 'tmp', 'int', 'plugin-eslint');

  let cwdSpy: MockInstance<[], string>;

  beforeAll(() => {
    cwdSpy = vi.spyOn(process, 'cwd');
  });

  afterAll(async () => {
    cwdSpy.mockRestore();
    await teardownTestFolder(tmpDir);
  });

  describe('React app', () => {
    const appRootDir = path.join(tmpDir, 'todos-app');
    const eslintrc = path.join(appRootDir, 'eslint.config.js');

    const patterns = ['src/**/*.js', 'src/**/*.jsx'];
    const targets: ESLintTarget[] = [{ eslintrc, patterns }];

    beforeAll(async () => {
      await cp(path.join(fixturesDir, 'todos-app'), appRootDir, {
        recursive: true,
      });
      await restoreNxIgnoredFiles(appRootDir);
      cwdSpy.mockReturnValue(appRootDir);
    });

    it('should list expected number of rules', async () => {
      await expect(listRules(targets)).resolves.toHaveLength(31);
    });

    it('should include explicitly set built-in rule', async () => {
      await expect(listRules(targets)).resolves.toContainEqual({
        id: 'no-const-assign',
        meta: {
          docs: {
            description: 'Disallow reassigning `const` variables',
            recommended: true,
            url: 'https://eslint.org/docs/latest/rules/no-const-assign',
          },
          messages: {
            const: "'{{name}}' is constant.",
          },
          schema: [],
          type: 'problem',
        },
        options: [],
      } satisfies RuleData);
    });

    it('should include explicitly set plugin rule', async () => {
      await expect(listRules(targets)).resolves.toContainEqual({
        id: 'react/jsx-key',
        meta: {
          docs: {
            category: 'Possible Errors',
            description:
              'Disallow missing `key` props in iterators/collection literals',
            recommended: true,
            url: 'https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-key.md',
          },
          messages: expect.any(Object),
          schema: [
            {
              additionalProperties: false,
              properties: {
                checkFragmentShorthand: { default: false, type: 'boolean' },
                checkKeyMustBeforeSpread: { default: false, type: 'boolean' },
                warnOnDuplicates: { default: false, type: 'boolean' },
              },
              type: 'object',
            },
          ],
        },
        options: [],
      } satisfies RuleData);
    });
  });

  describe('Nx monorepo project', () => {
    const nxRootDir = path.join(tmpDir, 'nx-monorepo');
    const eslintrc = path.join(nxRootDir, 'packages/utils/eslint.config.js');

    const patterns = ['packages/utils/**/*.ts', 'packages/utils/**/*.json'];
    const targets: ESLintTarget[] = [{ eslintrc, patterns }];

    beforeAll(async () => {
      await cp(path.join(fixturesDir, 'nx-monorepo'), nxRootDir, {
        recursive: true,
      });
      await restoreNxIgnoredFiles(nxRootDir);
      cwdSpy.mockReturnValue(nxRootDir);
    });

    it('should list expected number of rules', async () => {
      const rules = await listRules(targets);
      expect(rules.length).toBeGreaterThanOrEqual(50);
    });

    it('should include explicitly set plugin rule with custom options', async () => {
      // set in root eslint.config.js
      await expect(listRules(targets)).resolves.toContainEqual({
        id: '@nx/enforce-module-boundaries',
        meta: expect.any(Object),
        options: [
          expect.objectContaining({
            depConstraints: [
              {
                onlyDependOnLibsWithTags: ['*'],
                sourceTag: '*',
              },
            ],
            enforceBuildableLibDependency: true,
          }),
        ],
      } satisfies RuleData);
    });

    it('should include built-in rule set implicitly by extending recommended config', async () => {
      // extended via @nx/typescript -> @typescript-eslint/eslint-recommended
      await expect(listRules(targets)).resolves.toContainEqual({
        id: 'no-var',
        meta: expect.any(Object),
        options: [],
      } as RuleData);
    });

    it('should include plugin rule set implicitly by extending recommended config', async () => {
      // extended via @nx/typescript -> @typescript-eslint/recommended
      await expect(listRules(targets)).resolves.toContainEqual({
        id: '@typescript-eslint/no-unused-vars',
        meta: expect.any(Object),
        options: [],
      } satisfies RuleData);
    });

    it('should not include rule which was turned off in extended config', async () => {
      // extended TypeScript config sets "no-unused-semi": "off"
      await expect(listRules(targets)).resolves.not.toContainEqual(
        expect.objectContaining({
          id: 'no-unused-expressions',
        } satisfies Partial<RuleData>),
      );
    });

    it('should include rule added to root config by project config', async () => {
      // set only in packages/utils/eslint.config.js
      await expect(listRules(targets)).resolves.toContainEqual({
        id: '@nx/dependency-checks',
        meta: expect.any(Object),
        options: expect.any(Array),
      } satisfies RuleData);
    });
  });
});