code-tree-cli/defaults.test.js

Code Tree CLI

// Import.
import { getDefaultIgnorePatterns } from './defaults';
import { jest } from '@jest/globals';

/**
 * Check if getDefaultIgnorePatterns returns an object with expected categories.
 */
describe('getDefaultIgnorePatterns', () => {
  it('returns an object with all required categories', () => {
    const patterns = getDefaultIgnorePatterns();

    // Check if the function returns an object.
    expect(typeof patterns).toBe('object');

    // Check if the object contains all expected categories.
    const expectedCategories = ['system', 'images', 'videos', 'audio', 'documents', 'design', 'fonts', 'archives', 'binaries', 'databases', 'systemRelated', 'dumpFiles', 'xcode'];

    expectedCategories.forEach((category) => {
      expect(patterns).toHaveProperty(category);
    });
  });

  /**
   * Check if each category contains an array of patterns.
   */
  it('contains arrays of patterns for each category', () => {
    const patterns = getDefaultIgnorePatterns();

    // Check if each category contains an array.
    Object.keys(patterns).forEach((category) => {
      expect(Array.isArray(patterns[category])).toBe(true);
    });
  });

  /**
   * Check if common system files are included in the system category.
   */
  it('includes common system files in system category', () => {
    const patterns = getDefaultIgnorePatterns();

    // Check for specific important patterns.
    const requiredSystemPatterns = ['.git', 'node_modules', '.gitignore', '.vscode'];

    requiredSystemPatterns.forEach((pattern) => {
      expect(patterns.system).toContain(pattern);
    });
  });

  /**
   * Check if common media file extensions are included.
   */
  it('includes common media file extensions', () => {
    const patterns = getDefaultIgnorePatterns();

    // Check for specific image formats.
    const commonImageFormats = ['*.jpg', '*.png', '*.gif', '*.svg'];
    commonImageFormats.forEach((format) => {
      expect(patterns.images).toContain(format);
    });

    // Check for specific video formats.
    const commonVideoFormats = ['*.mp4', '*.mov', '*.avi'];
    commonVideoFormats.forEach((format) => {
      expect(patterns.videos).toContain(format);
    });
  });

  /**
   * Check if common binary file extensions are included.
   */
  it('includes common binary file extensions', () => {
    const patterns = getDefaultIgnorePatterns();

    // Check for specific binary formats.
    const commonBinaryFormats = ['*.exe', '*.dll', '*.so'];
    commonBinaryFormats.forEach((format) => {
      expect(patterns.binaries).toContain(format);
    });
  });

  /**
   * Check if all patterns are strings.
   */
  it('ensures all patterns are strings', () => {
    const patterns = getDefaultIgnorePatterns();

    Object.values(patterns).forEach((categoryPatterns) => {
      categoryPatterns.forEach((pattern) => {
        expect(typeof pattern).toBe('string');
      });
    });
  });

  /**
   * Check if there are no empty categories.
   */
  it('has no empty categories', () => {
    const patterns = getDefaultIgnorePatterns();

    Object.keys(patterns).forEach((category) => {
      expect(patterns[category].length).toBeGreaterThan(0);
    });
  });

  /**
   * Check if wildcard patterns start with asterisk.
   */
  it('formats extension patterns correctly with asterisk', () => {
    const patterns = getDefaultIgnorePatterns();
    const extensionCategories = ['images', 'videos', 'audio', 'documents', 'design', 'fonts', 'archives', 'binaries', 'databases'];

    extensionCategories.forEach((category) => {
      patterns[category].forEach((pattern) => {
        if (pattern.includes('*')) {
          expect(pattern.startsWith('*')).toBe(true);
        }
      });
    });
  });
});