@mui/internal-code-infra 0.0.4-canary.72 → 0.0.4-canary.74

package/src/brokenLinksChecker/index.test.ts

@@ -1,301 +0,0 @@
-import path from 'node:path';
-import getPort from 'get-port';
-import { describe, expect, it } from 'vitest';
-
-import {
-  crawl,
-  // eslint-disable-next-line import/extensions
-} from './index.mjs';
-import type {
-  BrokenLinkIssue,
-  HtmlValidateIssue,
-  Issue,
-  Link,
-  // eslint-disable-next-line import/extensions
-} from './index.mjs';
-
-type ExpectedBrokenLinkIssue = Omit<Partial<BrokenLinkIssue>, 'link'> & { link?: Partial<Link> };
-
-function objectMatchingIssue(expectedIssue: ExpectedBrokenLinkIssue) {
-  return expect.objectContaining({
-    ...expectedIssue,
-    ...(expectedIssue.link ? { link: expect.objectContaining(expectedIssue.link) } : {}),
-  });
-}
-
-/**
- * Helper to assert that a broken link issue with matching properties exists in the issues array
- */
-function expectIssue(issues: Issue[], expectedIssue: ExpectedBrokenLinkIssue) {
-  expect(issues).toEqual(expect.arrayContaining([objectMatchingIssue(expectedIssue)]));
-}
-
-/**
- * Helper to assert that no broken link issue with matching properties exists in the issues array
- */
-function expectNotIssue(issues: Issue[], notExpectedIssue: ExpectedBrokenLinkIssue) {
-  expect(issues).not.toEqual(expect.arrayContaining([objectMatchingIssue(notExpectedIssue)]));
-}
-
-describe('Broken Links Checker', () => {
-  const fixtureDir = path.join(import.meta.dirname, '__fixtures__', 'static-site');
-  const servePath = path.join(import.meta.dirname, '..', '..', 'node_modules', '.bin', 'serve');
-
-  it('should detect all broken links and targets across the entire site', async () => {
-    const port = await getPort();
-    const host = `http://localhost:${port}`;
-
-    const result = await crawl({
-      startCommand: `${servePath} ${fixtureDir} -p ${port}`,
-      host,
-      ignoredPaths: [/ignored-page\.html$/],
-      ignoredContent: ['.sidebar'],
-      ignoredTargets: new Set(['__should-be-ignored']),
-      knownTargets: new Map([['/external-page.html', new Set(['#valid-target'])]]),
-      knownTargetsDownloadUrl: [`${host}/known-targets.json`],
-      seedUrls: ['/', '/orphaned-page.html'],
-      // Test ignores with new array syntax and various property combinations
-      ignores: [
-        // Backward compatible: single values still work
-        { path: '/broken-links.html', href: '/does-not-exist.html' },
-        // Test array syntax: multiple hrefs in one rule (OR logic within property)
-        { path: '/broken-links.html', href: [/another-missing/, '../broken-relative-html.html'] },
-        // Test contentType: ignore broken links from markdown files
-        { contentType: 'text/markdown', href: '/broken-from-markdown.html' },
-        // Test href-only rule (matches from any page) - note: matches the actual href value
-        { href: 'broken-relative.html' },
-      ],
-      // Exercise the array form with union semantics: every matching entry
-      // contributes to the page's config. The baseline entry (no `path`)
-      // turns off `no-dup-id` everywhere; the path-specific entry turns off
-      // `no-raw-characters` only on /invalid-html.html. Both rules are
-      // silenced on that page because the configs are merged, not replaced.
-      //
-      // This also guards against the path-specific entry clobbering the
-      // baseline: the path entry only names `no-raw-characters`, so it must
-      // not re-introduce the recommended ruleset and re-enable the
-      // `no-dup-id` that the baseline silenced (which /invalid-html.html
-      // violates). If it did, that page would report `no-dup-id` below.
-      htmlValidate: [
-        { config: { rules: { 'no-dup-id': 'off' } } },
-        { path: '/invalid-html.html', config: { rules: { 'no-raw-characters': 'off' } } },
-      ],
-    });
-
-    expect(result.links).toHaveLength(67);
-    // Broken link issue count: original 11, minus ignored ones (broken-from-markdown via contentType,
-    // broken-relative via href-only rule)
-    const brokenLinkIssues = result.issues.filter(
-      (issue) => issue.type === 'broken-link' || issue.type === 'broken-target',
-    );
-    expect(brokenLinkIssues).toHaveLength(9);
-
-    // Test ignores: these broken links should be ignored (not in issues)
-    expectNotIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        src: '/broken-links.html',
-        href: '/does-not-exist.html',
-      },
-    });
-
-    expectNotIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        src: '/broken-links.html',
-        href: '/another-missing-page.html',
-      },
-    });
-
-    // Check broken-target type issues
-    expectIssue(result.issues, {
-      type: 'broken-target',
-      link: {
-        src: '/broken-targets.html',
-        href: '/with-anchors.html#nonexistent',
-        text: 'Non-existent anchor',
-      },
-    });
-
-    expectIssue(result.issues, {
-      type: 'broken-target',
-      link: {
-        src: '/broken-targets.html',
-        href: '/valid.html#missing-target',
-        text: 'Valid page, missing target',
-      },
-    });
-
-    expectIssue(result.issues, {
-      type: 'broken-target',
-      link: {
-        src: '/broken-targets.html',
-        href: '/with-anchors.html#also-missing',
-        text: 'Also missing',
-      },
-    });
-
-    // Verify that valid links are not reported
-    expectNotIssue(result.issues, { link: { href: '/' } });
-    expectNotIssue(result.issues, { link: { href: '/valid.html' } });
-    expectNotIssue(result.issues, { link: { href: '/with-anchors.html' } });
-    expectNotIssue(result.issues, { link: { href: '/with-anchors.html#section1' } });
-    expectNotIssue(result.issues, { link: { href: '/with-anchors.html#section2' } });
-    expectNotIssue(result.issues, { link: { href: '/with-anchors.html#section3' } });
-    expectNotIssue(result.issues, { link: { href: '/nested/page.html' } });
-
-    // Verify that external links are not reported
-    expectNotIssue(result.issues, { link: { href: 'https://example.com' } });
-    expectNotIssue(result.issues, { link: { href: 'https://github.com/mui' } });
-
-    // Test ignoredPaths: ignored-page.html should not be crawled
-    expectNotIssue(result.issues, { link: { src: '/ignored-page.html' } });
-    expectNotIssue(result.issues, { link: { href: '/this-link-should-not-be-checked.html' } });
-
-    // Test ignoredContent: links in .sidebar should be ignored
-    expectNotIssue(result.issues, { link: { href: '/sidebar-broken-link.html' } });
-
-    // Test ignoredTargets: IDs that shouldn't be tracked as valid link destinations
-    // (e.g., framework-specific IDs like '__next'). Links to these should be reported as broken.
-    expectIssue(result.issues, {
-      type: 'broken-target',
-      link: {
-        src: '/page-with-custom-targets.html',
-        href: '#__should-be-ignored',
-        text: 'Link to ignored ID',
-      },
-    });
-
-    // Test that non-ignored custom target is valid
-    expectNotIssue(result.issues, { link: { href: '/page-with-custom-targets.html#custom-id' } });
-
-    // Test knownTargets: valid-target is known and should not cause issues
-    expectNotIssue(result.issues, { link: { href: '/external-page.html#valid-target' } });
-
-    // Test knownTargets: invalid-target is not in knownTargets and should cause an issue
-    expectIssue(result.issues, {
-      type: 'broken-target',
-      link: {
-        src: '/page-with-known-target-links.html',
-        href: '/external-page.html#invalid-target',
-        text: 'Invalid external target',
-      },
-    });
-
-    // Test knownTargetsDownloadUrl: method1 and method2 are in downloaded known targets
-    expectNotIssue(result.issues, { link: { href: '/api-page.html#method1' } });
-    expectNotIssue(result.issues, { link: { href: '/api-page.html#method2' } });
-
-    // Test knownTargetsDownloadUrl: unknown-method is not in downloaded known targets and should cause an issue
-    expectIssue(result.issues, {
-      type: 'broken-target',
-      link: {
-        src: '/page-with-api-links.html',
-        href: '/api-page.html#unknown-method',
-        text: 'Unknown API method',
-      },
-    });
-
-    // Test seedUrls: orphaned-page.html should be crawled even though it's not linked from anywhere
-    expect(result.pages.has('/orphaned-page.html')).toBe(true);
-
-    // Test seedUrls: broken link from orphaned page should be detected
-    expectIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        src: '/orphaned-page.html',
-        href: '/orphaned-broken-link.html',
-        text: 'Broken link from orphaned page',
-      },
-    });
-
-    // Test trailing slash normalization: /valid.html and /valid.html/ should be treated as the same page
-    // The orphaned page has both links, but they should not cause duplicate page crawls
-    expectNotIssue(result.issues, { link: { href: '/valid.html/' } });
-
-    // Test contentType ignores: broken link from markdown should be ignored via contentType rule
-    expectNotIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        src: '/example.md',
-        href: '/broken-from-markdown.html',
-      },
-    });
-
-    // Valid links from markdown should not cause issues
-    expectNotIssue(result.issues, { link: { href: '/valid.html', src: '/example.md' } });
-    expectNotIssue(result.issues, {
-      link: { href: '/with-anchors.html#section1', src: '/example.md' },
-    });
-
-    // Links inside code blocks should NOT be extracted (they're text, not <a> tags)
-    expectNotIssue(result.issues, { link: { href: '/this-should-not-be-checked.html' } });
-
-    // Markdown file itself should be crawlable without issues
-    expectNotIssue(result.issues, { link: { href: '/example.md' } });
-
-    // Test that markdown heading anchors are discovered (rehype-slug)
-    expect(result.pages.get('/example.md')?.targets.has('#example-markdown-file')).toBe(true);
-    expect(result.pages.get('/example.md')?.targets.has('#markdown-section')).toBe(true);
-
-    // Test href-only ignores: broken-relative.html should be ignored from any page via href-only rule
-    expectNotIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        href: 'broken-relative.html',
-      },
-    });
-
-    // Valid relative links from markdown should not cause issues
-    expectNotIssue(result.issues, { link: { href: 'valid.html', src: '/example.md' } });
-    expectNotIssue(result.issues, { link: { href: './with-anchors.html', src: '/example.md' } });
-
-    // Test relative links in HTML
-    // Also verifies that the ignore pattern { path: /^\/broken-links\.html$/, href: '../broken-relative-html.html' }
-    // does NOT match this link since the path regex doesn't match /nested/page.html
-    expectIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        src: '/nested/page.html',
-        href: '../broken-relative-html.html',
-        text: 'Relative broken link from HTML',
-      },
-    });
-
-    // Valid relative links from HTML should not cause issues
-    expectNotIssue(result.issues, { link: { href: '../valid.html', src: '/nested/page.html' } });
-
-    // Test unclosed tags: links inside unclosed <main> tags should still be detected
-    // (regression test for node-html-parser parseNoneClosedTags option)
-    expectIssue(result.issues, {
-      type: 'broken-link',
-      link: {
-        src: '/unclosed-tags.html',
-        href: '/broken-inside-unclosed-main.html',
-        text: 'Broken link inside unclosed main',
-      },
-    });
-
-    // Valid links inside unclosed tags should not cause issues
-    expectNotIssue(result.issues, {
-      link: { href: '/valid.html', src: '/unclosed-tags.html' },
-    });
-
-    // Test contentType is stored on pageData
-    expect(result.pages.get('/example.md')?.contentType).toBe('text/markdown');
-    expect(result.pages.get('/')?.contentType).toBe('text/html');
-
-    // Test htmlValidate union semantics: invalid-html.html has both a duplicate
-    // ID (no-dup-id) and a raw `&` (no-raw-characters). The baseline entry
-    // silences no-dup-id; the path-specific entry silences no-raw-characters.
-    // Under union semantics both apply, so the page reports zero issues — and
-    // the path-specific entry must not clobber the baseline's no-dup-id.
-    const htmlValidateIssues = result.issues.filter(
-      (issue): issue is HtmlValidateIssue => issue.type === 'html-validate',
-    );
-    const invalidHtmlIssues = htmlValidateIssues.filter(
-      (issue) => issue.pageUrl === '/invalid-html.html',
-    );
-    expect(invalidHtmlIssues).toEqual([]);
-  }, 30000);
-});

package/src/changelog/categorizeCommits.test.ts

@@ -1,319 +0,0 @@
-import { describe, expect, it } from 'vitest';
-// eslint-disable-next-line import/extensions
-import { categorizeCommits } from './categorizeCommits.mjs';
-import type { FetchedCommitDetails, CategorizationConfig, LabelConfig } from './types';
-
-const baseLabelConfig: LabelConfig = {
-  plan: {
-    values: ['pro', 'premium'],
-  },
-  flags: {
-    'breaking change': { name: 'breaking change' },
-  },
-};
-
-function createCommit(
-  prNumber: number,
-  labels: string[],
-  overrides?: Partial<FetchedCommitDetails>,
-): FetchedCommitDetails {
-  return {
-    sha: `sha-${prNumber}`,
-    message: `feat: feature for PR #${prNumber}`,
-    labels,
-    prNumber,
-    html_url: `https://github.com/mui/mui-x/pull/${prNumber}`,
-    author: { login: 'dev', association: 'team' },
-    createdAt: null,
-    mergedAt: null,
-    ...overrides,
-  };
-}
-
-describe('categorizeCommits', () => {
-  describe('component strategy', () => {
-    const componentConfig: CategorizationConfig = {
-      strategy: 'component',
-      labels: baseLabelConfig,
-      sections: {
-        fallbackSection: 'Other',
-      },
-    };
-
-    it('should categorize commits by component label', () => {
-      const commits = [
-        createCommit(1, ['component: Button']),
-        createCommit(2, ['component: Checkbox']),
-        createCommit(3, ['component: Button']),
-      ];
-
-      const result = categorizeCommits(commits, componentConfig);
-
-      expect(result.size).toBe(2);
-      // Component labels are normalized to lowercase by parseCommitLabels
-      expect(result.get('Button')).toHaveLength(2);
-      expect(result.get('Checkbox')).toHaveLength(1);
-    });
-
-    it('should place commits without component labels in fallback section', () => {
-      const commits = [createCommit(1, []), createCommit(2, ['breaking change'])];
-
-      const result = categorizeCommits(commits, componentConfig);
-
-      expect(result.size).toBe(1);
-      expect(result.get('Other')).toHaveLength(2);
-    });
-
-    it('should place commits with multiple component labels in multiple sections', () => {
-      const commits = [createCommit(1, ['component: Button', 'component: Checkbox'])];
-
-      const result = categorizeCommits(commits, componentConfig);
-
-      expect(result.size).toBe(2);
-      // Component labels are normalized to lowercase by parseCommitLabels
-      expect(result.get('Button')).toHaveLength(1);
-      expect(result.get('Checkbox')).toHaveLength(1);
-      // Same commit object in both categories
-      expect(result.get('Button')?.[0].prNumber).toBe(1);
-      expect(result.get('Checkbox')?.[0].prNumber).toBe(1);
-    });
-
-    it('should use categoryOverride when present', () => {
-      const configWithOverrides: CategorizationConfig = {
-        ...componentConfig,
-        labels: {
-          ...baseLabelConfig,
-          categoryOverrides: {
-            'scope: all components': 'General changes',
-          },
-        },
-      };
-
-      const commits = [
-        createCommit(1, ['component: Button', 'scope: all components']),
-        createCommit(2, ['component: Checkbox']),
-        createCommit(3, ['component: Button', 'scope: all components']),
-      ];
-
-      const result = categorizeCommits(commits, configWithOverrides);
-
-      expect(result.size).toBe(2);
-      expect(result.get('General changes')).toHaveLength(2);
-      expect(result.get('General changes')?.[0].prNumber).toBe(1);
-      expect(result.get('General changes')?.[1].prNumber).toBe(3);
-      // Component labels are normalized to lowercase by parseCommitLabels
-      expect(result.get('Checkbox')).toHaveLength(1);
-    });
-  });
-
-  describe('package strategy', () => {
-    const packageConfig: CategorizationConfig = {
-      strategy: 'package',
-      labels: baseLabelConfig,
-      packageNaming: {
-        mappings: {
-          'data grid': '@mui/x-data-grid',
-          charts: '@mui/x-charts',
-          pickers: '@mui/x-date-pickers',
-        },
-        genericScopes: ['docs', 'code-infra'],
-        plans: {
-          pro: {
-            '@mui/x-data-grid': '@mui/x-data-grid-pro',
-            '@mui/x-charts': '@mui/x-charts-pro',
-            '@mui/x-date-pickers': '@mui/x-date-pickers-pro',
-          },
-          premium: {
-            '@mui/x-data-grid': '@mui/x-data-grid-premium',
-          },
-        },
-      },
-      sections: {
-        fallbackSection: 'Other',
-      },
-    };
-
-    it('should categorize commits by scope to package mapping', () => {
-      const commits = [
-        createCommit(1, ['scope: data grid']),
-        createCommit(2, ['scope: charts']),
-        createCommit(3, ['scope: data grid']),
-      ];
-
-      const result = categorizeCommits(commits, packageConfig);
-
-      expect(result.size).toBe(2);
-      expect(result.get('@mui/x-data-grid')).toHaveLength(2);
-      expect(result.get('@mui/x-charts')).toHaveLength(1);
-    });
-
-    it('should place commits without scope in fallback section', () => {
-      const commits = [createCommit(1, []), createCommit(2, ['breaking change'])];
-
-      const result = categorizeCommits(commits, packageConfig);
-
-      expect(result.size).toBe(1);
-      expect(result.get('Other')).toHaveLength(2);
-    });
-
-    it('should place commits with multiple scope labels in multiple sections', () => {
-      const commits = [createCommit(1, ['scope: data grid', 'scope: charts'])];
-
-      const result = categorizeCommits(commits, packageConfig);
-
-      expect(result.size).toBe(2);
-      expect(result.get('@mui/x-data-grid')).toHaveLength(1);
-      expect(result.get('@mui/x-charts')).toHaveLength(1);
-    });
-
-    it('should use generic scopes directly as section names', () => {
-      const commits = [createCommit(1, ['scope: docs']), createCommit(2, ['scope: code-infra'])];
-
-      const result = categorizeCommits(commits, packageConfig);
-
-      expect(result.size).toBe(2);
-      expect(result.get('docs')).toHaveLength(1);
-      expect(result.get('code-infra')).toHaveLength(1);
-    });
-
-    it('should apply plan to package name when plan label is present', () => {
-      const commits = [
-        createCommit(1, ['scope: data grid', 'plan: pro']),
-        createCommit(2, ['scope: data grid', 'plan: premium']),
-        createCommit(3, ['scope: data grid']),
-      ];
-
-      const result = categorizeCommits(commits, packageConfig);
-
-      expect(result.size).toBe(3);
-      expect(result.get('@mui/x-data-grid-pro')).toHaveLength(1);
-      expect(result.get('@mui/x-data-grid-premium')).toHaveLength(1);
-      expect(result.get('@mui/x-data-grid')).toHaveLength(1);
-    });
-
-    it('should throw error when scope mapping is not found', () => {
-      const commits = [createCommit(42, ['scope: unknown-package'])];
-
-      expect(() => categorizeCommits(commits, packageConfig)).toThrow(
-        'No package mapping found for scope "unknown-package" in commit #42',
-      );
-    });
-
-    it('should throw error when plan mapping is not found for package', () => {
-      const commits = [createCommit(42, ['scope: charts', 'plan: premium'])];
-
-      expect(() => categorizeCommits(commits, packageConfig)).toThrow(
-        'No premium plan package mapping found for base package "@mui/x-charts" in commit #42',
-      );
-    });
-
-    it('should throw error when package naming config is missing', () => {
-      const configWithoutNaming: CategorizationConfig = {
-        strategy: 'package',
-        labels: baseLabelConfig,
-        sections: {
-          fallbackSection: 'Other',
-        },
-      };
-
-      const commits = [createCommit(1, ['scope: data grid'])];
-
-      expect(() => categorizeCommits(commits, configWithoutNaming)).toThrow(
-        'Package naming configuration is required for package-first strategy',
-      );
-    });
-
-    it('should use categoryOverride when present', () => {
-      const configWithOverrides: CategorizationConfig = {
-        ...packageConfig,
-        labels: {
-          ...baseLabelConfig,
-          categoryOverrides: {
-            'scope: all components': 'General changes',
-          },
-        },
-      };
-
-      const commits = [
-        createCommit(1, ['scope: data grid', 'scope: all components']),
-        createCommit(2, ['scope: charts']),
-      ];
-
-      const result = categorizeCommits(commits, configWithOverrides);
-
-      expect(result.size).toBe(2);
-      expect(result.get('General changes')).toHaveLength(1);
-      expect(result.get('@mui/x-charts')).toHaveLength(1);
-    });
-  });
-
-  describe('unknown strategy', () => {
-    it('should throw error for unknown strategy', () => {
-      const invalidConfig = {
-        strategy: 'invalid' as 'component',
-        labels: baseLabelConfig,
-        sections: {
-          fallbackSection: 'Other',
-        },
-      };
-
-      const commits = [createCommit(1, [])];
-
-      expect(() => categorizeCommits(commits, invalidConfig)).toThrow(
-        'Unknown categorization strategy: invalid',
-      );
-    });
-  });
-
-  describe('parsed labels', () => {
-    const config: CategorizationConfig = {
-      strategy: 'component',
-      labels: {
-        ...baseLabelConfig,
-        flags: {
-          'breaking change': { name: 'breaking change' },
-          enhancement: { name: 'enhancement' },
-        },
-      },
-      sections: {
-        fallbackSection: 'Other',
-      },
-    };
-
-    it('should include parsed labels in categorized commits', () => {
-      const commits = [createCommit(1, ['component: Button', 'breaking change', 'enhancement'])];
-
-      const result = categorizeCommits(commits, config);
-
-      const categorizedCommit = result.get('Button')?.[0];
-      expect(categorizedCommit?.parsed.components).toEqual(['Button']);
-      expect(categorizedCommit?.parsed.flags).toEqual(['breaking change', 'enhancement']);
-    });
-
-    it('should include plan in parsed labels', () => {
-      const commits = [createCommit(1, ['component: Button', 'plan: pro'])];
-
-      const result = categorizeCommits(commits, config);
-
-      // Component labels are normalized to lowercase by parseCommitLabels
-      const categorizedCommit = result.get('Button')?.[0];
-      expect(categorizedCommit?.parsed.plan).toBe('pro');
-    });
-  });
-
-  describe('empty input', () => {
-    const config: CategorizationConfig = {
-      strategy: 'component',
-      labels: baseLabelConfig,
-      sections: {
-        fallbackSection: 'Other',
-      },
-    };
-
-    it('should return empty map for empty commits array', () => {
-      const result = categorizeCommits([], config);
-
-      expect(result.size).toBe(0);
-    });
-  });
-});