@cloud-ru/ft-deps-validator 1.1.1 → 1.1.2-preview-9ce1a08.0

package/src/Checker/__tests__/MonorepoChecker.spec.ts

@@ -0,0 +1,330 @@
+import depcheck from 'depcheck';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { MonorepoConfig } from '../../Config/MonorepoConfig';
+import { CheckState } from '../../Report';
+import { readPackageJsonFile, readPackageJsonFileSync } from '../../utils/readPackageJsonFile';
+import { MonorepoChecker } from '../MonorepoChecker';
+
+vi.mock('depcheck', () => ({
+  default: vi.fn(),
+}));
+
+vi.mock('../../utils/readPackageJsonFile', () => ({
+  readPackageJsonFile: vi.fn(),
+  readPackageJsonFileSync: vi.fn(),
+}));
+
+describe('MonorepoChecker', () => {
+  let mockConfig: MonorepoConfig;
+  const mockDepcheck = vi.mocked(depcheck);
+  const mockReadPackageJsonFile = vi.mocked(readPackageJsonFile);
+  const mockReadPackageJsonFileSync = vi.mocked(readPackageJsonFileSync);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockConfig = {
+      getFolders: vi.fn(),
+      getFolderOptions: vi.fn(),
+    } as unknown as MonorepoConfig;
+  });
+
+  describe('check', () => {
+    beforeEach(() => {
+      vi.mocked(mockConfig.getFolders).mockReturnValue([]);
+    });
+
+    it('should add wrongVersions when dependency version does not match', async () => {
+      const folders = ['/test/folder1', '/test/folder2'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync
+        .mockReturnValueOnce({
+          name: '@test/package1',
+          version: '1.0.0',
+          dependencies: {},
+          devDependencies: {},
+        })
+        .mockReturnValueOnce({
+          name: '@test/package2',
+          version: '2.0.0',
+          dependencies: {},
+          devDependencies: {},
+        });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: { '@test/package1': '1.1.0' },
+        devDependencies: {},
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should not add wrongVersions when dependency version matches', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: { '@test/package1': '1.0.0' },
+        devDependencies: {},
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(0);
+    });
+
+    it('should add to existing wrongVersions array', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = {
+        dependencies: [],
+        wrongVersions: ['existing error'],
+      };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: { '@test/package1': '1.1.0' },
+        devDependencies: {},
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should add internalAsDev when internal package is in devDependencies', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: { '@test/package1': '1.0.0' },
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should not add internalAsDev when package is not internal', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: { 'external-package': '1.0.0' },
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(0);
+    });
+
+    it('should add to existing internalAsDev array', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = {
+        dependencies: [],
+        internalAsDev: ['existing-package'],
+      };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: { '@test/package1': '1.0.0' },
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should handle multiple wrong versions', async () => {
+      const folders = ['/test/folder1', '/test/folder2'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync
+        .mockReturnValueOnce({
+          name: '@test/package1',
+          version: '1.0.0',
+          dependencies: {},
+          devDependencies: {},
+        })
+        .mockReturnValueOnce({
+          name: '@test/package2',
+          version: '2.0.0',
+          dependencies: {},
+          devDependencies: {},
+        });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: {
+          '@test/package1': '1.1.0',
+          '@test/package2': '2.1.0',
+        },
+        devDependencies: {},
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should handle both wrongVersions and internalAsDev', async () => {
+      const folders = ['/test/folder1', '/test/folder2'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync
+        .mockReturnValueOnce({
+          name: '@test/package1',
+          version: '1.0.0',
+          dependencies: {},
+          devDependencies: {},
+        })
+        .mockReturnValueOnce({
+          name: '@test/package2',
+          version: '2.0.0',
+          dependencies: {},
+          devDependencies: {},
+        });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: { '@test/package1': '1.1.0' },
+        devDependencies: { '@test/package2': '2.0.0' },
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should add wrongVersions for external packages (when actualVersion is undefined)', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: { 'external-package': '1.0.0' },
+        devDependencies: {},
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      // Текущая реализация добавляет ошибку для внешних пакетов,
+      // так как actualVersion === undefined, и условие undefined !== "1.0.0" будет true
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should handle empty dependencies and devDependencies', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      mockReadPackageJsonFileSync.mockReturnValue({
+        name: '@test/package1',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      mockReadPackageJsonFile.mockResolvedValue({
+        name: 'test-package',
+        version: '1.0.0',
+        dependencies: {},
+        devDependencies: {},
+      });
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new MonorepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(0);
+    });
+  });
+});

package/src/Checker/__tests__/RepoChecker.spec.ts

@@ -0,0 +1,132 @@
+import depcheck from 'depcheck';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { RepoConfig } from '../../Config/RepoConfig';
+import { CheckState } from '../../Report';
+import { RepoChecker } from '../RepoChecker';
+
+vi.mock('depcheck', () => ({
+  default: vi.fn(),
+}));
+
+describe('RepoChecker', () => {
+  let mockConfig: RepoConfig;
+  const mockDepcheck = vi.mocked(depcheck);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockConfig = {
+      getFolders: vi.fn(),
+      getFolderOptions: vi.fn(),
+    } as unknown as RepoConfig;
+  });
+
+  describe('constructor', () => {
+    it('should initialize with config', () => {
+      const checker = new RepoChecker(mockConfig);
+
+      expect(checker).toBeInstanceOf(RepoChecker);
+    });
+  });
+
+  describe('check', () => {
+    it('should call getFolders on config', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+
+      const checker = new RepoChecker(mockConfig);
+      await checker.check();
+
+      expect(mockConfig.getFolders).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call checkFolder for each folder', async () => {
+      const folders = ['/test/folder1', '/test/folder2'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      const checkState1: CheckState = { dependencies: ['dep1'] };
+      const checkState2: CheckState = { dependencies: ['dep2'] };
+      mockDepcheck.mockResolvedValueOnce(checkState1).mockResolvedValueOnce(checkState2);
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new RepoChecker(mockConfig);
+      await checker.check();
+
+      expect(mockDepcheck).toHaveBeenCalledTimes(2);
+    });
+
+    it('should call getFolderOptions for each folder with correct path', async () => {
+      const folders = ['/test/folder1', '/test/folder2'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      const options1 = { ignoreBinPackage: false };
+      const options2 = { ignoreBinPackage: false };
+      vi.mocked(mockConfig.getFolderOptions)
+        .mockReturnValueOnce(options1 as never)
+        .mockReturnValueOnce(options2 as never);
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+
+      const checker = new RepoChecker(mockConfig);
+      await checker.check();
+
+      expect(mockConfig.getFolderOptions).toHaveBeenCalledWith('/test/folder1');
+      expect(mockConfig.getFolderOptions).toHaveBeenCalledWith('/test/folder2');
+    });
+
+    it('should call depcheck with correct path and options', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      const options = { ignoreBinPackage: false, skipMissing: false };
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue(options as never);
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+
+      const checker = new RepoChecker(mockConfig);
+      await checker.check();
+
+      expect(mockDepcheck).toHaveBeenCalledWith('/test/folder1', options);
+    });
+
+    it('should add results to report for each folder', async () => {
+      const folders = ['/test/folder1', '/test/folder2'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      const checkState1: CheckState = { dependencies: ['dep1'] };
+      const checkState2: CheckState = { dependencies: ['dep2'] };
+      mockDepcheck.mockResolvedValueOnce(checkState1).mockResolvedValueOnce(checkState2);
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new RepoChecker(mockConfig);
+      const report = await checker.check();
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+    });
+
+    it('should return Report instance', async () => {
+      const folders = ['/test/folder1'];
+      vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+      const checkState: CheckState = { dependencies: [] };
+      mockDepcheck.mockResolvedValue(checkState);
+      vi.mocked(mockConfig.getFolderOptions).mockReturnValue({} as never);
+
+      const checker = new RepoChecker(mockConfig);
+      const report = await checker.check();
+
+      expect(report).toBeDefined();
+      expect(report.printResultAndGetExitCode).toBeDefined();
+    });
+
+    it('should handle empty folders array', async () => {
+      vi.mocked(mockConfig.getFolders).mockReturnValue([]);
+
+      const checker = new RepoChecker(mockConfig);
+      const report = await checker.check();
+
+      expect(mockDepcheck).not.toHaveBeenCalled();
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(0);
+    });
+  });
+});

package/src/Checker/index.ts

@@ -0,0 +1,2 @@
+export { RepoChecker } from './RepoChecker';
+export { MonorepoChecker } from './MonorepoChecker';

package/src/Config/MonorepoConfig.ts

@@ -0,0 +1,51 @@
+import { Options } from 'depcheck';
+import { globSync } from 'glob';
+import path from 'node:path';
+
+import { MonorepoEnvType } from '../types';
+import { RepoConfig } from './RepoConfig';
+
+export class MonorepoConfig extends RepoConfig {
+  private rootPackagesFolderPattern: string;
+  private ignoredPackagesFolderFiles: string[];
+  private packages: Exclude<MonorepoEnvType['packages'], undefined>;
+  private folders?: string[];
+
+  constructor(env: MonorepoEnvType) {
+    super(env);
+    this.rootPackagesFolderPattern = env.rootPackagesFolderPattern;
+    this.ignoredPackagesFolderFiles = env.ignoredPackagesFolderFiles || [];
+    this.packages = env.packages || {};
+  }
+
+  public getFolderOptions(folderPath: string): Options {
+    const options = super.getFolderOptions(folderPath);
+
+    const folder = path.basename(folderPath);
+
+    const folderIgnores = this.packages[folder];
+
+    if (!folderIgnores) {
+      return options;
+    }
+
+    if (folderIgnores.ignorePatterns?.length) {
+      options.ignorePatterns = [...(options.ignorePatterns || []), ...folderIgnores.ignorePatterns];
+    }
+    if (folderIgnores.ignoreMatches?.length) {
+      options.ignoreMatches = [...(options.ignoreMatches || []), ...folderIgnores.ignoreMatches];
+    }
+
+    return options;
+  }
+
+  public getFolders(): string[] {
+    if (!this.folders) {
+      this.folders = globSync(this.rootPackagesFolderPattern, {
+        ignore: this.ignoredPackagesFolderFiles,
+      });
+    }
+
+    return this.folders.map(folder => path.resolve(this.pwd, folder));
+  }
+}

package/src/Config/RepoConfig.ts

@@ -0,0 +1,30 @@
+import { Options } from 'depcheck';
+import path from 'node:path';
+
+import { RepoEnvType } from '../types';
+
+export class RepoConfig {
+  protected pwd: string;
+  private ignorePatterns?: string[];
+  private ignoreMatches?: string[];
+
+  constructor(env: RepoEnvType) {
+    this.pwd = path.resolve(env.cwd);
+    this.ignoreMatches = env.ignoreMatches || [];
+    this.ignorePatterns = env.ignorePatterns || [];
+  }
+
+  public getFolders() {
+    return [this.pwd];
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getFolderOptions(_folder: string): Options {
+    return {
+      ignoreBinPackage: false,
+      skipMissing: false,
+      ignorePatterns: this.ignorePatterns,
+      ignoreMatches: this.ignoreMatches,
+    };
+  }
+}