commitlint-config-spellbookx 1.1.1 → 1.1.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # commitlint-config-spellbookx
 
+## 1.1.2
+
+### Patch Changes
+
+- chore(release): automated patch release bump
+
 ## 1.1.1
 
 ### Patch Changes

package/__tests__/index.test.ts

@@ -1,9 +1,4 @@
-/**
- * @file index.test.ts
- * Tests verifying the main configuration export and metadata of commitlint-config-spellbookx.
- */
-
-import { describe, expect, test } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import defaultExport, {
   COMMIT_TYPES,
@@ -17,12 +12,11 @@ import defaultExport, {
 } from '../src/index.js';
 import { packageJson } from '../src/lib/package-json.js';
 
-describe('commitlint-config-spellbookx entrypoint', () => {
-  test('should export valid configuration object', () => {
+describe('commitlint-config-spellbookx (entrypoint)', () => {
+  it('exports a valid commitlint UserConfig object as default and named export', () => {
     expect(defaultExport).toBe(config);
-    expect(typeof config).toBe('object');
-    expect(Array.isArray(config.extends)).toBe(true);
-    expect(config.extends).toContain('@commitlint/config-conventional');
+    expect(config).toBeTypeOf('object');
+    expect(config.extends).toEqual(['@commitlint/config-conventional']);
     expect(config.parserPreset).toBe(
       'conventional-changelog-conventionalcommits'
     );
@@ -30,18 +24,41 @@ describe('commitlint-config-spellbookx entrypoint', () => {
     expect(config.prompt).toBe(prompt);
   });
 
-  test('should contain valid package metadata in helpers', () => {
+  it('exposes accurate package metadata', () => {
     expect(packageJson.name).toBe('commitlint-config-spellbookx');
-    expect(packageJson.version).toBeDefined();
+    expect(packageJson.version).toMatch(/^\d+\.\d+\.\d+/);
+  });
+
+  it('exports all 11 standard conventional commit types', () => {
+    expect(COMMIT_TYPES).toEqual([
+      'feat',
+      'fix',
+      'docs',
+      'style',
+      'refactor',
+      'perf',
+      'test',
+      'chore',
+      'ci',
+      'build',
+      'revert',
+    ]);
+  });
+
+  it('configures cz-git interactive prompt questions and settings', () => {
+    expect(prompt?.settings?.enableMultipleScopes).toBe(true);
+    expect(prompt?.settings?.scopeEnumSeparator).toBe(',');
+    expect(prompt?.questions?.scope?.enum).toBe(scopesEnum);
+
+    for (const type of COMMIT_TYPES) {
+      expect(prompt?.questions?.type?.enum?.[type]).toBeDefined();
+    }
   });
 
-  test('should export conventional commit types and scope constants', () => {
-    expect(Array.isArray(COMMIT_TYPES)).toBe(true);
-    expect(COMMIT_TYPES).toContain('feat');
-    expect(COMMIT_TYPES).toContain('fix');
+  it('exports special scope constants and dynamically discovered scopes', () => {
     expect(SCOPE_WORKSPACE).toBe('workspace');
     expect(SCOPE_RELEASE).toBe('release');
     expect(Array.isArray(scopesArray)).toBe(true);
-    expect(typeof scopesEnum).toBe('object');
+    expect(scopesEnum).toBeTypeOf('object');
   });
 });

package/__tests__/lint.test.ts

@@ -1,65 +1,37 @@
-/**
- * @file lint.test.ts
- * Tests verifying conventional commit validation rules using `@commitlint/lint`.
- */
-
-import { describe, expect, test } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import lint from '@commitlint/lint';
 
 import config from '../src/index.js';
 
-describe('commitlint validation rules', () => {
-  test('should validate valid conventional commits', async () => {
-    const result = await lint(
-      'feat(eslint-plugin-spellbookx): add new awesome feature',
-      config.rules
-    );
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  test('should validate valid workspace scope commits', async () => {
-    const result = await lint(
-      'chore(workspace): update root configs',
-      config.rules
-    );
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
+describe('commitlint-config-spellbookx (lint rules)', () => {
+  it.each([
+    'feat(eslint-plugin-spellbookx): add new flat config preset',
+    'fix(prettier-config-spellbookx): resolve plugin sort order',
+    'chore(workspace): update root dependencies',
+    'chore(release): bump to v1.1.1',
+    'docs(@spellbookx/recipes): document ignore globs',
+    'test(spellbookx): rewrite test suite with vitest',
+  ])('accepts valid conventional commit: "%s"', async (message) => {
+    const result = await lint(message, config.rules);
 
-  test('should validate valid release scope commits', async () => {
-    const result = await lint('feat(release): publish v1.0.0', config.rules);
     expect(result.valid).toBe(true);
     expect(result.errors).toHaveLength(0);
   });
 
-  test('should fail when type is invalid', async () => {
-    const result = await lint('unknown(workspace): some change', config.rules);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.name === 'type-enum')).toBe(true);
-  });
-
-  test('should fail when scope is not in scope-enum', async () => {
-    const result = await lint(
-      'feat(nonexistent-scope): some change',
-      config.rules
-    );
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.name === 'scope-enum')).toBe(true);
-  });
-
-  test('should fail when subject has a trailing period', async () => {
-    const result = await lint('fix(workspace): fix config typo.', config.rules);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.name === 'subject-full-stop')).toBe(
-      true
-    );
-  });
-
-  test('should fail when subject is empty', async () => {
-    const result = await lint('fix(workspace): ', config.rules);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.name === 'subject-empty')).toBe(true);
-  });
+  it.each([
+    ['unknown(workspace): invalid commit type', 'type-enum'],
+    ['feat(nonexistent-scope): unknown package scope', 'scope-enum'],
+    ['fix(workspace): trailing period in subject.', 'subject-full-stop'],
+    ['fix(workspace): ', 'subject-empty'],
+    [`feat(workspace): ${'a'.repeat(80)}`, 'header-max-length'],
+  ])(
+    'rejects invalid commit "%s" with rule "%s"',
+    async (message, expectedRule) => {
+      const result = await lint(message, config.rules);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((err) => err.name === expectedRule)).toBe(true);
+    }
+  );
 });

package/__tests__/scopes.test.ts

@@ -1,9 +1,4 @@
-/**
- * @file scopes.test.ts
- * Tests for scope identifiers, scope descriptions, and scopes enumeration.
- */
-
-import { describe, expect, test } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import {
   getScopeDescription,
@@ -13,43 +8,35 @@ import {
   scopesEnum,
 } from '../src/index.js';
 
-describe('commitlint scopes', () => {
-  test('constants should be properly defined', () => {
+describe('commitlint-config-spellbookx (scopes)', () => {
+  it('defines workspace and release scope constants', () => {
     expect(SCOPE_WORKSPACE).toBe('workspace');
     expect(SCOPE_RELEASE).toBe('release');
   });
 
-  test('scopesArray should contain workspace, release, and monorepo packages', () => {
-    expect(Array.isArray(scopesArray)).toBe(true);
-    expect(scopesArray).toContain(SCOPE_WORKSPACE);
-    expect(scopesArray).toContain(SCOPE_RELEASE);
-    expect(scopesArray).toContain('commitlint-config-spellbookx');
-    expect(scopesArray).toContain('cspell-config-spellbookx');
-    expect(scopesArray).toContain('eslint-plugin-spellbookx');
-    expect(scopesArray).toContain('prettier-config-spellbookx');
-    expect(scopesArray).toContain('@spellbookx/recipes');
+  it.each([
+    SCOPE_WORKSPACE,
+    SCOPE_RELEASE,
+    '@spellbookx/recipes',
+    'commitlint-config-spellbookx',
+    'cspell-config-spellbookx',
+    'eslint-plugin-spellbookx',
+    'prettier-config-spellbookx',
+    'spellbookx',
+  ])('includes "%s" in scopesArray and scopesEnum', (scope) => {
+    expect(scopesArray).toContain(scope);
+    expect(scopesEnum[scope]).toEqual({
+      description: getScopeDescription(scope),
+    });
   });
 
-  test('getScopeDescription should return user-friendly descriptions', () => {
+  it('returns descriptive text for special and package scopes', () => {
     expect(getScopeDescription(SCOPE_WORKSPACE)).toBe(
       'workspace scope - root files such as config files, root package.json, etc'
     );
     expect(getScopeDescription(SCOPE_RELEASE)).toBe(
       'Special scope for release commits'
     );
-    expect(getScopeDescription('custom-pkg')).toBe('custom-pkg scope');
-  });
-
-  test('scopesEnum should populate descriptions for all scopes', () => {
-    expect(scopesEnum[SCOPE_WORKSPACE]?.description).toBe(
-      getScopeDescription(SCOPE_WORKSPACE)
-    );
-    expect(scopesEnum[SCOPE_RELEASE]?.description).toBe(
-      getScopeDescription(SCOPE_RELEASE)
-    );
-    for (const scope of scopesArray) {
-      expect(scopesEnum[scope]).toBeDefined();
-      expect(scopesEnum[scope]?.description).toBe(getScopeDescription(scope));
-    }
+    expect(getScopeDescription('my-custom-pkg')).toBe('my-custom-pkg scope');
   });
 });

package/__tests__/workspaces.test.ts

@@ -1,13 +1,15 @@
-/**
- * @file workspaces.test.ts
- * Tests for git root discovery, workspace config parsing, and scopes gathering.
- */
-
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import {
   findGitRoot,
@@ -16,61 +18,120 @@ import {
 } from '../src/lib/index.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const testDir = path.resolve(__dirname, '../temp-test-commitlint');
 
-describe('workspace discovery and parsing', () => {
-  beforeAll(() => {
-    if (existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
-    mkdirSync(testDir, { recursive: true });
-  });
+describe('commitlint-config-spellbookx (workspace discovery)', () => {
+  let tempDir: string;
 
-  afterAll(() => {
-    if (existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
+  beforeEach(() => {
+    tempDir = mkdtempSync(path.join(os.tmpdir(), 'sbx-commitlint-'));
   });
 
-  test('findGitRoot should locate git root directory', () => {
-    const root = findGitRoot(__dirname);
-    expect(root).not.toBeNull();
-    expect(existsSync(path.join(root!, '.git'))).toBe(true);
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
   });
 
-  test('should parse workspaces from JSON correctly', () => {
-    const jsonPath = path.join(testDir, 'package.json');
-    mkdirSync(testDir, { recursive: true });
-    writeFileSync(
-      jsonPath,
-      JSON.stringify({ workspaces: ['packages/*', 'apps/*'] })
-    );
+  describe('findGitRoot', () => {
+    it('locates the git root directory from a nested package path', () => {
+      const root = findGitRoot(__dirname);
 
-    const workspaces = getWorkspacesRawPath(jsonPath, 'json', 'workspaces');
-    expect(workspaces).toEqual(['packages/*', 'apps/*']);
-  });
+      expect(root).not.toBeNull();
+      expect(existsSync(path.join(root!, '.git'))).toBe(true);
+    });
 
-  test('should parse packages from YAML correctly', () => {
-    const yamlPath = path.join(testDir, 'pnpm-workspace.yaml');
-    mkdirSync(testDir, { recursive: true });
-    writeFileSync(yamlPath, 'packages:\n  - "packages/*"\n  - "plugins/*"\n');
+    it('returns null when no .git directory exists up to filesystem root', () => {
+      const root = findGitRoot(tempDir);
 
-    const packages = getWorkspacesRawPath(yamlPath, 'yaml', 'packages');
-    expect(packages).toEqual(['packages/*', 'plugins/*']);
+      expect(root).toBeNull();
+    });
   });
 
-  test('should throw on unsupported parser', () => {
-    const filePath = path.join(testDir, 'config.txt');
-    writeFileSync(filePath, 'some text');
-    expect(() => {
-      // @ts-expect-error Testing invalid parser
-      getWorkspacesRawPath(filePath, 'xml');
-    }).toThrow(/Unsupported parser type/);
+  describe('getWorkspacesRawPath', () => {
+    it('parses workspace globs from a JSON file', () => {
+      const jsonPath = path.join(tempDir, 'package.json');
+      writeFileSync(
+        jsonPath,
+        JSON.stringify({ workspaces: ['packages/*', 'apps/*'] })
+      );
+
+      expect(getWorkspacesRawPath(jsonPath, 'json', 'workspaces')).toEqual([
+        'packages/*',
+        'apps/*',
+      ]);
+    });
+
+    it('parses package globs from a YAML file', () => {
+      const yamlPath = path.join(tempDir, 'pnpm-workspace.yaml');
+      writeFileSync(yamlPath, 'packages:\n  - "packages/*"\n  - "plugins/*"\n');
+
+      expect(getWorkspacesRawPath(yamlPath, 'yaml', 'packages')).toEqual([
+        'packages/*',
+        'plugins/*',
+      ]);
+    });
+
+    it('returns an empty array when file does not exist or property is missing', () => {
+      expect(
+        getWorkspacesRawPath(path.join(tempDir, 'missing.json'), 'json')
+      ).toEqual([]);
+
+      const jsonPath = path.join(tempDir, 'empty.json');
+      writeFileSync(jsonPath, JSON.stringify({ name: 'no-workspaces' }));
+      expect(getWorkspacesRawPath(jsonPath, 'json', 'workspaces')).toEqual([]);
+    });
+
+    it('throws an error when given an unsupported parser type', () => {
+      const filePath = path.join(tempDir, 'config.txt');
+      writeFileSync(filePath, 'content');
+
+      expect(() => {
+        // @ts-expect-error Testing invalid parser runtime check
+        getWorkspacesRawPath(filePath, 'xml');
+      }).toThrow(/Unsupported parser type: xml/);
+    });
   });
 
-  test('should return scopes including workspace and monorepo packages', () => {
-    const scopes = getScopes();
-    expect(Array.isArray(scopes)).toBe(true);
-    expect(scopes).toContain('commitlint-config-spellbookx');
-    expect(scopes).toContain('cspell-config-spellbookx');
-    expect(scopes).toContain('eslint-plugin-spellbookx');
-    expect(scopes).toContain('prettier-config-spellbookx');
-    expect(scopes).toContain('@spellbookx/recipes');
+  describe('getScopes', () => {
+    it('discovers all package scopes in the current monorepo', () => {
+      const scopes = getScopes(__dirname);
+
+      expect(scopes).toEqual(
+        expect.arrayContaining([
+          '@spellbookx/recipes',
+          'commitlint-config-spellbookx',
+          'cspell-config-spellbookx',
+          'eslint-plugin-spellbookx',
+          'prettier-config-spellbookx',
+          'spellbookx',
+        ])
+      );
+    });
+
+    it('discovers scopes from a simulated git repository with workspaces and ignores malformed package.json', () => {
+      mkdirSync(path.join(tempDir, '.git'));
+      writeFileSync(
+        path.join(tempDir, 'package.json'),
+        JSON.stringify({ name: 'root-pkg', workspaces: ['packages/*'] })
+      );
+
+      const pkgA = path.join(tempDir, 'packages/pkg-a');
+      const pkgInvalid = path.join(tempDir, 'packages/pkg-invalid');
+      mkdirSync(pkgA, { recursive: true });
+      mkdirSync(pkgInvalid, { recursive: true });
+
+      writeFileSync(
+        path.join(pkgA, 'package.json'),
+        JSON.stringify({ name: '@acme/pkg-a' })
+      );
+      writeFileSync(path.join(pkgInvalid, 'package.json'), '{ invalid json');
+
+      const scopes = getScopes(tempDir);
+
+      expect(scopes).toContain('root-pkg');
+      expect(scopes).toContain('@acme/pkg-a');
+    });
+
+    it('throws a fatal error when invoked outside a git repository', () => {
+      expect(() => getScopes(tempDir)).toThrow('[FATAL] Not a repository.');
+    });
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commitlint-config-spellbookx",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "private": false,
   "description": "A shareable Commitlint configuration for enforcing conventional commits.",
   "keywords": [
@@ -90,6 +90,6 @@
   "scripts": {
     "build": "rolldown -c && tsc",
     "release": "pnpm publish --access public --no-git-checks",
-    "test": "vitest run"
+    "test": "vitest run --no-fsModuleCache"
   }
 }