Refactor tests into separate files and improve PathProjectSelectorParser testability

Co-authored-by: dmichon-msft <26827560+dmichon-msft@users.noreply.github.com>

Author: Copilot

libraries/rush-lib/src/api/test/repo/rush-npm.json

@@ -27,20 +27,23 @@
     {
       "packageName": "project1",
       "projectFolder": "project1",
-      "reviewCategory": "third-party"
+      "reviewCategory": "third-party",
+      "tags": ["frontend", "ui"]
     },
 
     {
       "packageName": "project2",
       "projectFolder": "project2",
       "reviewCategory": "third-party",
-      "skipRushCheck": true
+      "skipRushCheck": true,
+      "tags": ["backend"]
     },
 
     {
       "packageName": "project3",
       "projectFolder": "project3",
-      "reviewCategory": "prototype"
+      "reviewCategory": "prototype",
+      "tags": ["frontend"]
     }
   ]
 }

libraries/rush-lib/src/logic/selectors/PathProjectSelectorParser.ts

@@ -13,9 +13,11 @@ import { RushConstants } from '../RushConstants';
 
 export class PathProjectSelectorParser implements ISelectorParser<RushConfigurationProject> {
   private readonly _rushConfiguration: RushConfiguration;
+  private readonly _workingDirectory: string;
 
-  public constructor(rushConfiguration: RushConfiguration) {
+  public constructor(rushConfiguration: RushConfiguration, workingDirectory?: string) {
     this._rushConfiguration = rushConfiguration;
+    this._workingDirectory = workingDirectory ?? process.cwd();
   }
 
   public async evaluateSelectorAsync({
@@ -24,7 +26,7 @@ export class PathProjectSelectorParser implements ISelectorParser<RushConfigurat
     parameterName
   }: IEvaluateSelectorOptions): Promise<Iterable<RushConfigurationProject>> {
     // Resolve the input path against the working directory
-    const absolutePath: string = nodePath.resolve(process.cwd(), unscopedSelector);
+    const absolutePath: string = nodePath.resolve(this._workingDirectory, unscopedSelector);
 
     // Relativize it to the rushJsonFolder
     const relativePath: string = nodePath.relative(this._rushConfiguration.rushJsonFolder, absolutePath);

libraries/rush-lib/src/logic/selectors/test/NamedProjectSelectorParser.test.ts

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+import * as path from 'node:path';
+
+import { StringBufferTerminalProvider, Terminal } from '@rushstack/terminal';
+
+import { RushConfiguration } from '../../../api/RushConfiguration';
+import { NamedProjectSelectorParser } from '../NamedProjectSelectorParser';
+
+describe(NamedProjectSelectorParser.name, () => {
+  let rushConfiguration: RushConfiguration;
+  let terminal: Terminal;
+  let terminalProvider: StringBufferTerminalProvider;
+  let parser: NamedProjectSelectorParser;
+
+  beforeEach(() => {
+    const rushJsonFile: string = path.resolve(__dirname, '../../../api/test/repo/rush-npm.json');
+    rushConfiguration = RushConfiguration.loadFromConfigurationFile(rushJsonFile);
+    terminalProvider = new StringBufferTerminalProvider();
+    terminal = new Terminal(terminalProvider);
+    parser = new NamedProjectSelectorParser(rushConfiguration);
+  });
+
+  it('should select a project by exact package name', async () => {
+    const result = await parser.evaluateSelectorAsync({
+      unscopedSelector: 'project1',
+      terminal,
+      parameterName: '--only'
+    });
+
+    const projects = Array.from(result);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].packageName).toBe('project1');
+  });
+
+  it('should throw error for non-existent project', async () => {
+    await expect(
+      parser.evaluateSelectorAsync({
+        unscopedSelector: 'nonexistent',
+        terminal,
+        parameterName: '--only'
+      })
+    ).rejects.toThrow();
+  });
+
+  it('should provide completions for all projects', () => {
+    const completions = Array.from(parser.getCompletions());
+    expect(completions).toContain('project1');
+    expect(completions).toContain('project2');
+    expect(completions).toContain('project3');
+  });
+});

libraries/rush-lib/src/logic/selectors/test/PathProjectSelectorParser.test.ts

@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+import * as path from 'node:path';
+
+import { StringBufferTerminalProvider, Terminal } from '@rushstack/terminal';
+
+import { RushConfiguration } from '../../../api/RushConfiguration';
+import { PathProjectSelectorParser } from '../PathProjectSelectorParser';
+
+describe(PathProjectSelectorParser.name, () => {
+  let rushConfiguration: RushConfiguration;
+  let terminal: Terminal;
+  let terminalProvider: StringBufferTerminalProvider;
+  let parser: PathProjectSelectorParser;
+
+  beforeEach(() => {
+    const rushJsonFile: string = path.resolve(__dirname, '../../../api/test/repo/rush-npm.json');
+    rushConfiguration = RushConfiguration.loadFromConfigurationFile(rushJsonFile);
+    terminalProvider = new StringBufferTerminalProvider();
+    terminal = new Terminal(terminalProvider);
+    parser = new PathProjectSelectorParser(rushConfiguration, rushConfiguration.rushJsonFolder);
+  });
+
+  it('should select a project by exact path', async () => {
+    const result = await parser.evaluateSelectorAsync({
+      unscopedSelector: 'project1',
+      terminal,
+      parameterName: '--only'
+    });
+
+    const projects = Array.from(result);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].packageName).toBe('project1');
+  });
+
+  it('should select a project by path within the project', async () => {
+    const result = await parser.evaluateSelectorAsync({
+      unscopedSelector: 'project1/src/index.ts',
+      terminal,
+      parameterName: '--only'
+    });
+
+    const projects = Array.from(result);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].packageName).toBe('project1');
+  });
+
+  it('should select multiple projects from a parent directory', async () => {
+    const result = await parser.evaluateSelectorAsync({
+      unscopedSelector: '.',
+      terminal,
+      parameterName: '--only'
+    });
+
+    const projects = Array.from(result);
+    expect(projects.length).toBeGreaterThan(0);
+    // Should include all projects in the test repo
+    const packageNames = projects.map((p) => p.packageName).sort();
+    expect(packageNames).toContain('project1');
+    expect(packageNames).toContain('project2');
+    expect(packageNames).toContain('project3');
+  });
+
+  it('should select project from specified directory', async () => {
+    const project1Path = path.join(rushConfiguration.rushJsonFolder, 'project1');
+    const parserWithCustomCwd = new PathProjectSelectorParser(rushConfiguration, project1Path);
+
+    const result = await parserWithCustomCwd.evaluateSelectorAsync({
+      unscopedSelector: '.',
+      terminal,
+      parameterName: '--only'
+    });
+
+    const projects = Array.from(result);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].packageName).toBe('project1');
+  });
+
+  it('should handle absolute paths', async () => {
+    const absolutePath = path.join(rushConfiguration.rushJsonFolder, 'project2');
+
+    const result = await parser.evaluateSelectorAsync({
+      unscopedSelector: absolutePath,
+      terminal,
+      parameterName: '--only'
+    });
+
+    const projects = Array.from(result);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].packageName).toBe('project2');
+  });
+
+  it('should throw error for paths that do not match any project', async () => {
+    await expect(
+      parser.evaluateSelectorAsync({
+        unscopedSelector: 'nonexistent/path',
+        terminal,
+        parameterName: '--only'
+      })
+    ).rejects.toThrow();
+  });
+
+  it('should handle paths outside workspace', async () => {
+    // Paths outside the workspace should not match any project and throw
+    await expect(
+      parser.evaluateSelectorAsync({
+        unscopedSelector: '../outside',
+        terminal,
+        parameterName: '--only'
+      })
+    ).rejects.toThrow();
+  });
+
+  it('should return empty completions', () => {
+    const completions = Array.from(parser.getCompletions());
+    expect(completions).toHaveLength(0);
+  });
+});