refactor(@angular/cli): clean up MCP tests and use real project name for default projects

Author: amishne

packages/angular/cli/src/commands/mcp/devserver.ts

@@ -64,10 +64,6 @@ export interface Devserver {
   port: number;
 }
 
-export function devserverKey(project?: string) {
-  return project ?? '<default>';
-}
-
 /**
  * A local Angular development server managed by the MCP server.
  */

packages/angular/cli/src/commands/mcp/testing/test-utils.ts

@@ -0,0 +1,91 @@
+/**
+ * @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 { workspaces } from '@angular-devkit/core';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { AngularWorkspace } from '../../../utilities/config';
+import { type Devserver } from '../devserver';
+import { Host } from '../host';
+import { McpToolContext } from '../tools/tool-registry';
+import { MockHost } from './mock-host';
+
+/**
+ * Creates a mock implementation of the Host interface for testing purposes.
+ * Each method is a Jasmine spy that can be configured.
+ */
+export function createMockHost(): MockHost {
+  return {
+    runCommand: jasmine.createSpy<Host['runCommand']>('runCommand').and.resolveTo({ logs: [] }),
+    stat: jasmine.createSpy<Host['stat']>('stat'),
+    existsSync: jasmine.createSpy<Host['existsSync']>('existsSync'),
+    spawn: jasmine.createSpy<Host['spawn']>('spawn'),
+    getAvailablePort: jasmine
+      .createSpy<Host['getAvailablePort']>('getAvailablePort')
+      .and.resolveTo(0),
+  } as unknown as MockHost;
+}
+
+/**
+ * Options for configuring the mock MCP tool context.
+ */
+export interface MockContextOptions {
+  /** An optional pre-configured mock host. If not provided, a default mock host will be created. */
+  host?: MockHost;
+
+  /** Initial set of projects to populate the mock workspace with. */
+  projects?: Record<string, workspaces.ProjectDefinition>;
+}
+
+/**
+ * Creates a comprehensive mock for the McpToolContext, including a mock Host,
+ * an AngularWorkspace, and a ProjectDefinitionCollection. This simplifies testing
+ * MCP tools by providing a consistent and configurable testing environment.
+ * @param options Configuration options for the mock context.
+ * @returns An object containing the mock host, context, projects collection, and workspace instance.
+ */
+export function createMockContext(options: MockContextOptions = {}): {
+  host: MockHost;
+  context: McpToolContext;
+  projects: workspaces.ProjectDefinitionCollection;
+  workspace: AngularWorkspace;
+} {
+  const host = options.host ?? createMockHost();
+  const projects = new workspaces.ProjectDefinitionCollection(options.projects);
+  const workspace = new AngularWorkspace({ projects, extensions: {} }, '/test/angular.json');
+
+  const context: McpToolContext = {
+    server: {} as unknown as McpServer,
+    workspace,
+    logger: { warn: () => {} },
+    devservers: new Map<string, Devserver>(),
+    host,
+  };
+
+  return { host, context, projects, workspace };
+}
+
+/**
+ * Adds a project to the provided mock ProjectDefinitionCollection.
+ * This is a helper function to easily populate a mock Angular workspace.
+ * @param projects The ProjectDefinitionCollection to add the project to.
+ * @param name The name of the project.
+ * @param targets A record of target definitions for the project (e.g., build, test, e2e).
+ * @param root The root path of the project, relative to the workspace root. Defaults to `projects/${name}`.
+ */
+export function addProjectToWorkspace(
+  projects: workspaces.ProjectDefinitionCollection,
+  name: string,
+  targets: Record<string, workspaces.TargetDefinition> = {},
+  root = `projects/${name}`,
+) {
+  projects.set(name, {
+    root,
+    extensions: {},
+    targets: new workspaces.TargetDefinitionCollection(targets),
+  });
+}

packages/angular/cli/src/commands/mcp/tools/build.ts

@@ -8,7 +8,7 @@
 
 import { z } from 'zod';
 import { CommandError, type Host } from '../host';
-import { createStructuredContentOutput } from '../utils';
+import { createStructuredContentOutput, getCommandErrorLogs } from '../utils';
 import { type McpToolDeclaration, declareTool } from './tool-registry';
 
 const DEFAULT_CONFIGURATION = 'development';
@@ -55,13 +55,7 @@ export async function runBuild(input: BuildToolInput, host: Host) {
     logs = (await host.runCommand('ng', args)).logs;
   } catch (e) {
     status = 'failure';
-    if (e instanceof CommandError) {
-      logs = e.logs;
-    } else if (e instanceof Error) {
-      logs = [e.message];
-    } else {
-      logs = [String(e)];
-    }
+    logs = getCommandErrorLogs(e);
   }
 
   for (const line of logs) {

packages/angular/cli/src/commands/mcp/tools/build_spec.ts

@@ -6,19 +6,16 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import { CommandError, Host } from '../host';
+import { CommandError } from '../host';
 import type { MockHost } from '../testing/mock-host';
+import { createMockHost } from '../testing/test-utils';
 import { runBuild } from './build';
 
 describe('Build Tool', () => {
   let mockHost: MockHost;
 
   beforeEach(() => {
-    mockHost = {
-      runCommand: jasmine.createSpy<Host['runCommand']>('runCommand').and.resolveTo({ logs: [] }),
-      stat: jasmine.createSpy<Host['stat']>('stat'),
-      existsSync: jasmine.createSpy<Host['existsSync']>('existsSync'),
-    } as MockHost;
+    mockHost = createMockHost();
   });
 
   it('should construct the command correctly with default configuration', async () => {
@@ -82,7 +79,7 @@ describe('Build Tool', () => {
       'production',
     ]);
     expect(structuredContent.status).toBe('failure');
-    expect(structuredContent.logs).toEqual(buildLogs);
+    expect(structuredContent.logs).toEqual([...buildLogs, 'Build failed']);
     expect(structuredContent.path).toBeUndefined();
   });
 

packages/angular/cli/src/commands/mcp/tools/devserver/devserver-start.ts

@@ -7,8 +7,8 @@
  */
 
 import { z } from 'zod';
-import { LocalDevserver, devserverKey } from '../../devserver';
-import { createStructuredContentOutput } from '../../utils';
+import { LocalDevserver } from '../../devserver';
+import { createStructuredContentOutput, getDefaultProjectName } from '../../utils';
 import { type McpToolContext, type McpToolDeclaration, declareTool } from '../tool-registry';
 
 const devserverStartToolInputSchema = z.object({
@@ -39,12 +39,18 @@ function localhostAddress(port: number) {
 }
 
 export async function startDevserver(input: DevserverStartToolInput, context: McpToolContext) {
-  const projectKey = devserverKey(input.project);
+  const projectName = input.project ?? getDefaultProjectName(context);
 
-  let devserver = context.devservers.get(projectKey);
+  if (!projectName) {
+    return createStructuredContentOutput({
+      message: ['Project name not provided, and no default project found.'],
+    });
+  }
+
+  let devserver = context.devservers.get(projectName);
   if (devserver) {
     return createStructuredContentOutput({
-      message: `Development server for project '${projectKey}' is already running.`,
+      message: `Development server for project '${projectName}' is already running.`,
       address: localhostAddress(devserver.port),
     });
   }
@@ -54,10 +60,10 @@ export async function startDevserver(input: DevserverStartToolInput, context: Mc
   devserver = new LocalDevserver({ host: context.host, project: input.project, port });
   devserver.start();
 
-  context.devservers.set(projectKey, devserver);
+  context.devservers.set(projectName, devserver);
 
   return createStructuredContentOutput({
-    message: `Development server for project '${projectKey}' started and watching for workspace changes.`,
+    message: `Development server for project '${projectName}' started and watching for workspace changes.`,
     address: localhostAddress(port),
   });
 }

packages/angular/cli/src/commands/mcp/tools/devserver/devserver-stop.ts

@@ -7,8 +7,7 @@
  */
 
 import { z } from 'zod';
-import { devserverKey } from '../../devserver';
-import { createStructuredContentOutput } from '../../utils';
+import { createStructuredContentOutput, getDefaultProjectName } from '../../utils';
 import { type McpToolContext, type McpToolDeclaration, declareTool } from '../tool-registry';
 
 const devserverStopToolInputSchema = z.object({
@@ -30,21 +29,41 @@ const devserverStopToolOutputSchema = z.object({
 export type DevserverStopToolOutput = z.infer<typeof devserverStopToolOutputSchema>;
 
 export function stopDevserver(input: DevserverStopToolInput, context: McpToolContext) {
-  const projectKey = devserverKey(input.project);
-  const devServer = context.devservers.get(projectKey);
+  if (context.devservers.size === 0) {
+    return createStructuredContentOutput({
+      message: ['No development servers are currently running.'],
+      logs: undefined,
+    });
+  }
+
+  let projectName = input.project ?? getDefaultProjectName(context);
+
+  if (!projectName) {
+    // This should not happen. But if there's just a single running devserver, stop it.
+    if (context.devservers.size === 1) {
+      projectName = Array.from(context.devservers.keys())[0];
+    } else {
+      return createStructuredContentOutput({
+        message: ['Project name not provided, and no default project found.'],
+        logs: undefined,
+      });
+    }
+  }
+
+  const devServer = context.devservers.get(projectName);
 
   if (!devServer) {
     return createStructuredContentOutput({
-      message: `Development server for project '${projectKey}' was not running.`,
+      message: `Development server for project '${projectName}' was not running.`,
       logs: undefined,
     });
   }
 
   devServer.stop();
-  context.devservers.delete(projectKey);
+  context.devservers.delete(projectName);
 
   return createStructuredContentOutput({
-    message: `Development server for project '${projectKey}' stopped.`,
+    message: `Development server for project '${projectName}' stopped.`,
     logs: devServer.getServerLogs(),
   });
 }

packages/angular/cli/src/commands/mcp/tools/devserver/devserver-wait-for-build.ts

@@ -7,8 +7,7 @@
  */
 
 import { z } from 'zod';
-import { devserverKey } from '../../devserver';
-import { createStructuredContentOutput } from '../../utils';
+import { createStructuredContentOutput, getDefaultProjectName } from '../../utils';
 import { type McpToolContext, type McpToolDeclaration, declareTool } from '../tool-registry';
 
 /**
@@ -60,21 +59,43 @@ export async function waitForDevserverBuild(
   input: DevserverWaitForBuildToolInput,
   context: McpToolContext,
 ) {
-  const projectKey = devserverKey(input.project);
-  const devServer = context.devservers.get(projectKey);
-  const deadline = Date.now() + input.timeout;
+  if (context.devservers.size === 0) {
+    return createStructuredContentOutput({
+      status: 'no_devserver_found',
+      logs: undefined,
+    });
+  }
+
+  let projectName = input.project ?? getDefaultProjectName(context);
+
+  if (!projectName) {
+    // This should not happen. But if there's just a single running devserver, wait for it.
+    if (context.devservers.size === 1) {
+      projectName = Array.from(context.devservers.keys())[0];
+    } else {
+      return createStructuredContentOutput({
+        status: 'no_devserver_found',
+        logs: undefined,
+      });
+    }
+  }
+
+  const devServer = context.devservers.get(projectName);
 
   if (!devServer) {
     return createStructuredContentOutput<DevserverWaitForBuildToolOutput>({
       status: 'no_devserver_found',
+      logs: undefined,
     });
   }
 
+  const deadline = Date.now() + input.timeout;
   await wait(WATCH_DELAY);
   while (devServer.isBuilding()) {
     if (Date.now() > deadline) {
       return createStructuredContentOutput<DevserverWaitForBuildToolOutput>({
         status: 'timeout',
+        logs: undefined,
       });
     }
     await wait(WATCH_DELAY);