test(@angular/build): add unit tests for test discovery logic

The `test-discovery.ts` file contains critical logic for finding test files based on user-defined glob patterns and static paths. This logic was previously not fully tested, making it difficult to refactor safely and prone to regressions.

This commit introduces a unit test suite for the `findTests` and `getTestEntrypoints` functions. It uses a mocked file system to cover various scenarios, including:

- Dynamic glob pattern resolution
- Static directory and file path expansion
- Correct application of exclusion patterns
- De-duplication of results

Author: clydin

packages/angular/build/src/builders/karma/find-tests_spec.ts

@@ -0,0 +1,183 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as tinyglobby from 'tinyglobby';
+import { findTests, getTestEntrypoints } from '../test-discovery';
+
+const WORKSPACE_ROOT = '/my/workspace/root';
+const PROJECT_SOURCE_ROOT = '/my/workspace/root/src-root';
+
+describe('findTests', () => {
+  let globSpy: jasmine.Spy;
+  let statSpy: jasmine.Spy;
+  let accessSpy: jasmine.Spy;
+
+  beforeEach(() => {
+    globSpy = spyOn(tinyglobby, 'glob').and.returnValue(Promise.resolve([]));
+    statSpy = spyOn(fs, 'stat').and.returnValue(Promise.reject(new Error('Not a file.')));
+    accessSpy = spyOn(fs, 'access').and.returnValue(
+      Promise.reject(new Error('File does not exist.')),
+    );
+  });
+
+  function posixPath(p: string): string {
+    return p.replace(/\\/g, '/');
+  }
+
+  it('finds tests using a simple glob', async () => {
+    globSpy.and.returnValue(Promise.resolve(['/my/workspace/root/src-root/app/app.spec.ts']));
+
+    const files = await findTests(['**/*.spec.ts'], [], WORKSPACE_ROOT, PROJECT_SOURCE_ROOT);
+    expect(files).toEqual(['/my/workspace/root/src-root/app/app.spec.ts']);
+    expect(posixPath(globSpy.calls.mostRecent().args[0][0])).toBe('**/*.spec.ts');
+  });
+
+  it('excludes files using an exclude pattern', async () => {
+    globSpy.and.returnValue(Promise.resolve(['/my/workspace/root/src-root/app/app.spec.ts']));
+
+    await findTests(['**/*.spec.ts'], ['**/e2e/**'], WORKSPACE_ROOT, PROJECT_SOURCE_ROOT);
+
+    expect(globSpy.calls.mostRecent().args[1].ignore).toContain('**/e2e/**');
+  });
+
+  it('expands a static directory path', async () => {
+    statSpy.and.callFake(async (p: string) => ({ isDirectory: () => p.endsWith('app') }));
+
+    await findTests(['app'], [], WORKSPACE_ROOT, PROJECT_SOURCE_ROOT);
+
+    expect(posixPath(globSpy.calls.mostRecent().args[0][0])).toBe('app/**/*.spec.@(ts|tsx)');
+  });
+
+  it('resolves a static file path to its spec file', async () => {
+    accessSpy.and.callFake(async (p: string) => {
+      if (p.endsWith('app.component.spec.ts')) {
+        return;
+      }
+      throw new Error('File does not exist.');
+    });
+
+    const files = await findTests(
+      ['app/app.component.ts'],
+      [],
+      WORKSPACE_ROOT,
+      PROJECT_SOURCE_ROOT,
+    );
+
+    expect(files).toEqual([path.join(PROJECT_SOURCE_ROOT, 'app/app.component.spec.ts')]);
+    expect(globSpy).not.toHaveBeenCalled();
+  });
+
+  it('deduplicates files found by multiple patterns', async () => {
+    globSpy.and.callFake(async (patterns: string[]) => {
+      if (patterns.includes('src/app/**/*.spec.ts')) {
+        return ['/my/workspace/root/src-root/app/app.spec.ts'];
+      }
+      if (patterns.includes('src/lib/**/*.spec.ts')) {
+        return ['/my/workspace/root/src-root/app/app.spec.ts'];
+      }
+      return [];
+    });
+
+    const files = await findTests(
+      ['src/app/**/*.spec.ts', 'src/lib/**/*.spec.ts'],
+      [],
+      WORKSPACE_ROOT,
+      PROJECT_SOURCE_ROOT,
+    );
+
+    expect(files).toEqual(['/my/workspace/root/src-root/app/app.spec.ts']);
+  });
+});
+
+describe('getTestEntrypoints', () => {
+  const UNIX_ENTRYPOINTS_OPTIONS = {
+    workspaceRoot: '/my/workspace/root',
+    projectSourceRoot: '/my/workspace/root/src-root',
+  };
+
+  const WINDOWS_ENTRYPOINTS_OPTIONS = {
+    workspaceRoot: 'C:\\my\\workspace\\root',
+    projectSourceRoot: 'C:\\my\\workspace\\root\\src-root',
+  };
+
+  for (const options of [UNIX_ENTRYPOINTS_OPTIONS, WINDOWS_ENTRYPOINTS_OPTIONS]) {
+    describe(`with path separator "${path.sep}"`, () => {
+      function joinWithSeparator(base: string, rel: string) {
+        return path.join(base, rel);
+      }
+
+      function getEntrypoints(workspaceRelative: string[], sourceRootRelative: string[] = []) {
+        return getTestEntrypoints(
+          [
+            ...workspaceRelative.map((p) => joinWithSeparator(options.workspaceRoot, p)),
+            ...sourceRootRelative.map((p) => joinWithSeparator(options.projectSourceRoot, p)),
+          ],
+          options,
+        );
+      }
+
+      it('returns an empty map without test files', () => {
+        expect(getEntrypoints([])).toEqual(new Map());
+      });
+
+      it('strips workspace root and/or project source root', () => {
+        expect(getEntrypoints(['a/b.spec.js'], ['c/d.spec.js'])).toEqual(
+          new Map<string, string>([
+            ['spec-a-b.spec', joinWithSeparator(options.workspaceRoot, 'a/b.spec.js')],
+            ['spec-c-d.spec', joinWithSeparator(options.projectSourceRoot, 'c/d.spec.js')],
+          ]),
+        );
+      });
+
+      it('adds unique prefixes to distinguish between similar names', () => {
+        expect(getEntrypoints(['a/b/c/d.spec.js', 'a-b/c/d.spec.js'], ['a/b-c/d.spec.js'])).toEqual(
+          new Map<string, string>([
+            ['spec-a-b-c-d.spec', joinWithSeparator(options.workspaceRoot, 'a/b/c/d.spec.js')],
+            ['spec-a-b-c-d-2.spec', joinWithSeparator(options.workspaceRoot, 'a-b/c/d.spec.js')],
+            [
+              'spec-a-b-c-d-3.spec',
+              joinWithSeparator(options.projectSourceRoot, 'a/b-c/d.spec.js'),
+            ],
+          ]),
+        );
+      });
+
+      describe('with removeTestExtension enabled', () => {
+        function getEntrypoints(workspaceRelative: string[], sourceRootRelative: string[] = []) {
+          return getTestEntrypoints(
+            [
+              ...workspaceRelative.map((p) => joinWithSeparator(options.workspaceRoot, p)),
+              ...sourceRootRelative.map((p) => joinWithSeparator(options.projectSourceRoot, p)),
+            ],
+            { ...options, removeTestExtension: true },
+          );
+        }
+
+        it('removes .spec extension', () => {
+          expect(getEntrypoints(['a/b.spec.js'], ['c/d.spec.js'])).toEqual(
+            new Map<string, string>([
+              ['spec-a-b', joinWithSeparator(options.workspaceRoot, 'a/b.spec.js')],
+              ['spec-c-d', joinWithSeparator(options.projectSourceRoot, 'c/d.spec.js')],
+            ]),
+          );
+        });
+
+        it('removes .test extension', () => {
+          expect(getEntrypoints(['a/b.test.js'], ['c/d.test.js'])).toEqual(
+            new Map<string, string>([
+              ['spec-a-b', joinWithSeparator(options.workspaceRoot, 'a/b.test.js')],
+              ['spec-c-d', joinWithSeparator(options.projectSourceRoot, 'c/d.test.js')],
+            ]),
+          );
+        });
+      });
+    });
+  }
+});