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: string = `projects/${name}`,
+) {
+  projects.set(name, {
+    root,
+    extensions: {},
+    targets: new workspaces.TargetDefinitionCollection(targets),
+  });
+}

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 () => {

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);

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

@@ -8,7 +8,9 @@
 
 import { EventEmitter } from 'events';
 import type { ChildProcess } from 'node:child_process';
+import { AngularWorkspace } from '../../../../utilities/config';
 import type { MockHost } from '../../testing/mock-host';
+import { addProjectToWorkspace, createMockContext } from '../../testing/test-utils';
 import type { McpToolContext } from '../tool-registry';
 import { startDevserver } from './devserver-start';
 import { stopDevserver } from './devserver-stop';
@@ -25,33 +27,36 @@ describe('Serve Tools', () => {
   let mockContext: McpToolContext;
   let mockProcess: MockChildProcess;
   let portCounter: number;
+  let mockWorkspace: AngularWorkspace;
 
   beforeEach(() => {
     portCounter = 12345;
     mockProcess = new MockChildProcess();
-    mockHost = {
-      spawn: jasmine.createSpy('spawn').and.returnValue(mockProcess as unknown as ChildProcess),
-      getAvailablePort: jasmine.createSpy('getAvailablePort').and.callFake(() => {
-        return Promise.resolve(portCounter++);
-      }),
-    } as MockHost;
-
-    mockContext = {
-      devservers: new Map(),
-      host: mockHost,
-    } as Partial<McpToolContext> as McpToolContext;
+
+    const mock = createMockContext();
+    mockHost = mock.host;
+    mockContext = mock.context;
+    mockWorkspace = mock.workspace;
+
+    // Customize host spies
+    mockHost.spawn.and.returnValue(mockProcess as unknown as ChildProcess);
+    mockHost.getAvailablePort.and.callFake(() => Promise.resolve(portCounter++));
+
+    // Setup default project
+    addProjectToWorkspace(mock.projects, 'my-app');
+    mockWorkspace.extensions['defaultProject'] = 'my-app';
   });
 
   it('should start and stop a dev server', async () => {
     const startResult = await startDevserver({}, mockContext);
     expect(startResult.structuredContent.message).toBe(
-      `Development server for project '<default>' started and watching for workspace changes.`,
+      `Development server for project 'my-app' started and watching for workspace changes.`,
     );
     expect(mockHost.spawn).toHaveBeenCalledWith('ng', ['serve', '--port=12345'], { stdio: 'pipe' });
 
     const stopResult = stopDevserver({}, mockContext);
     expect(stopResult.structuredContent.message).toBe(
-      `Development server for project '<default>' stopped.`,
+      `Development server for project 'my-app' stopped.`,
     );
     expect(mockProcess.kill).toHaveBeenCalled();
   });
@@ -78,6 +83,11 @@ describe('Serve Tools', () => {
   });
 
   it('should handle multiple dev servers', async () => {
+    // Add extra projects
+    const projects = mockWorkspace.projects;
+    addProjectToWorkspace(projects, 'app-one');
+    addProjectToWorkspace(projects, 'app-two');
+
     // Start server for project 1. This uses the basic mockProcess created for the tests.
     const startResult1 = await startDevserver({ project: 'app-one' }, mockContext);
     expect(startResult1.structuredContent.message).toBe(
@@ -117,6 +127,7 @@ describe('Serve Tools', () => {
   });
 
   it('should handle server crash', async () => {
+    addProjectToWorkspace(mockWorkspace.projects, 'crash-app');
     await startDevserver({ project: 'crash-app' }, mockContext);
 
     // Simulate a crash with exit code 1
@@ -129,6 +140,7 @@ describe('Serve Tools', () => {
   });
 
   it('wait should timeout if build takes too long', async () => {
+    addProjectToWorkspace(mockWorkspace.projects, 'timeout-app');
     await startDevserver({ project: 'timeout-app' }, mockContext);
     const waitResult = await waitForDevserverBuild(
       { project: 'timeout-app', timeout: 10 },