@google-cloud/cloud-run-mcp 1.5.0 → 1.7.0

package/test/local/mcp-server-stdio.test.js

@@ -0,0 +1,59 @@
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'child_process';
+import { waitForString } from './test-utils.js';
+
+describe('MCP Server stdio startup', () => {
+  let serverProcess;
+  let stderr = '';
+  const stdioMsg = 'Cloud Run MCP server stdio transport connected';
+
+  describe('when GCP_STDIO=true', () => {
+    before(async () => {
+      stderr = '';
+      serverProcess = spawn('node', ['mcp-server.js'], {
+        cwd: process.cwd(),
+        env: { ...process.env, GCP_STDIO: 'true' },
+      });
+      stderr = await waitForString(serverProcess.stderr, stdioMsg);
+    });
+
+    after(() => {
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
+
+    test('should start in stdio mode', () => {
+      assert.ok(stderr.includes(stdioMsg));
+    });
+  });
+
+  describe('when GCP_STDIO=false', () => {
+    before(async () => {
+      stderr = '';
+      const env = { ...process.env };
+      env.GCP_STDIO = 'false';
+      serverProcess = spawn('node', ['mcp-server.js'], {
+        cwd: process.cwd(),
+        env: env,
+      });
+      const stderrChunks = [];
+      serverProcess.stderr.on('data', (chunk) => {
+        stderrChunks.push(chunk);
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      stderr = Buffer.concat(stderrChunks).toString();
+    });
+
+    after(() => {
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
+
+    test('should not start in stdio mode', () => {
+      assert.ok(!stderr.includes(stdioMsg));
+    });
+  });
+});

package/test/local/mcp-server-streamable-http.test.js

@@ -0,0 +1,61 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'child_process';
+import { waitForString } from './test-utils.js';
+
+class MCPClient {
+  client = null;
+  transport = null;
+
+  constructor(serverName) {
+    this.client = new Client({
+      name: `mcp-client-for-${serverName}`,
+      version: '1.0.0',
+      url: `http://localhost:3000/mcp`,
+    });
+  }
+
+  async connectToServer(serverUrl) {
+    this.transport = new StreamableHTTPClientTransport(serverUrl);
+    await this.client.connect(this.transport);
+  }
+
+  async cleanup() {
+    await this.client.close();
+  }
+}
+
+describe('MCP Server in Streamble HTTP mode', () => {
+  let client;
+  let serverProcess;
+  let stdout = '';
+  const httpMsg = 'Cloud Run MCP server listening on port 3000';
+
+  describe('when GCP_STDIO=false', () => {
+    before(async () => {
+      stdout = '';
+      // Start MCP server as a child process
+      serverProcess = spawn('node', ['mcp-server.js'], {
+        cwd: process.cwd(),
+        env: { ...process.env, GCP_STDIO: 'false' },
+      });
+      stdout = await waitForString(serverProcess.stdout, httpMsg);
+
+      client = new MCPClient('http-server');
+    });
+
+    after(async () => {
+      await client.cleanup();
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
+
+    test('should start an HTTP server', async () => {
+      await client.connectToServer('http://localhost:3000/mcp');
+      assert.ok(stdout.includes(httpMsg));
+    });
+  });
+});

package/test/local/notifications.test.js

@@ -8,12 +8,15 @@ describe('Tool Notifications', () => {
       registerTool: mock.fn(),
     };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-      '../../lib/cloud-run-deploy.js': {
-        deploy: () => Promise.resolve({ uri: 'my-uri' }),
-      },
-    },
-  );
+    const { registerTools } = await esmock(
+      '../../tools/tools.js',
+      {},
+      {
+        '../../lib/deployment/deployer.js': {
+          deploy: () => Promise.resolve({ uri: 'my-uri' }),
+        },
+      }
+    );
 
     registerTools(server, { gcpCredentialsAvailable: true });
 

package/test/local/source-processor.test.js

@@ -0,0 +1,290 @@
+/*
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { test, describe, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import esmock from 'esmock';
+
+describe('Source Processor', () => {
+  const fspMock = {
+    mkdir: mock.fn(),
+    stat: mock.fn(),
+    copyFile: mock.fn(),
+    rm: mock.fn(),
+  };
+
+  const childProcessMock = {
+    exec: mock.fn(),
+  };
+
+  test('prepareSourceDirectory creates temp dir and copies files', async () => {
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs/promises': fspMock,
+        'node:child_process': childProcessMock,
+      }
+    );
+
+    const files = ['/path/to/source/file1.js', '/path/to/source/dir1'];
+
+    fspMock.stat.mock.mockImplementation(async (filePath) => {
+      if (filePath.endsWith('dir1')) return { isDirectory: () => true };
+      return { isDirectory: () => false };
+    });
+
+    // Mock exec for directory copy (cp -R)
+    childProcessMock.exec.mock.mockImplementation((cmd, callback) => {
+      // Handle sync callback for util.promisify
+      if (callback) callback(null, 'ok', '');
+    });
+
+    const progressCallback = mock.fn();
+
+    const tempDir = await sourceProcessor.prepareSourceDirectory(
+      files,
+      progressCallback
+    );
+
+    assert.ok(
+      tempDir.includes('file1.js-'),
+      'Temp dir should have expected prefix (based on first filename)'
+    );
+
+    assert.equal(fspMock.mkdir.mock.callCount(), 1);
+    assert.equal(fspMock.copyFile.mock.callCount(), 1); // for file1.js
+
+    // Check if cp -R was called for dir1
+    const execCalls = childProcessMock.exec.mock.calls;
+    const cpCall = execCalls.find((call) =>
+      call.arguments[0].startsWith('cp -R')
+    );
+    assert.ok(cpCall, 'Should call cp -R for directories');
+  });
+
+  test('installDependencies runs npm install for Node.js', async () => {
+    // We need to mock fs.existsSync as well
+    const fsMock = {
+      existsSync: mock.fn(),
+    };
+
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs': fsMock,
+        'node:fs/promises': fspMock,
+        'node:child_process': childProcessMock,
+      }
+    );
+
+    const targetDir = '/temp/dir';
+    const deploymentAttrs = {
+      runtime: 'nodejs',
+      cmd: ['node', 'server.js'],
+      args: ['server.js'],
+      baseImage: 'node:22',
+    };
+    const progressCallback = mock.fn();
+
+    // Mock existsSync
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.includes('node_modules')) return false; // not installed yet
+      if (p.includes('package-lock.json')) return false; // no lock file
+      return false;
+    });
+
+    // Mock exec for npm install
+    childProcessMock.exec.mock.mockImplementation((cmd, opts, callback) => {
+      if (typeof opts === 'function') callback = opts;
+      if (callback) callback(null, 'ok', '');
+    });
+
+    await sourceProcessor.installDependencies(
+      targetDir,
+      deploymentAttrs,
+      progressCallback
+    );
+
+    const calls = childProcessMock.exec.mock.calls;
+    const npmCall = calls.find((call) =>
+      call.arguments[0].includes('npm install')
+    );
+    assert.ok(npmCall, 'Should run npm install');
+    assert.strictEqual(npmCall.arguments[1].cwd, targetDir);
+  });
+
+  test('installDependencies uses npm ci if lockfile exists', async () => {
+    const fsMock = {
+      existsSync: mock.fn(),
+    };
+
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs': fsMock,
+        'node:child_process': childProcessMock,
+      }
+    );
+
+    const targetDir = '/temp/dir';
+    const deploymentAttrs = {
+      runtime: 'nodejs',
+      cmd: ['node', 'server.js'],
+      args: ['server.js'],
+      baseImage: 'node:22',
+    };
+
+    // Mock existsSync
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.includes('node_modules')) return false;
+      if (p.includes('package-lock.json')) return true; // has lock file
+      return false;
+    });
+
+    childProcessMock.exec.mock.mockImplementation((cmd, opts, callback) => {
+      if (typeof opts === 'function') callback = opts;
+      if (callback) callback(null, 'ok', '');
+    });
+
+    await sourceProcessor.installDependencies(
+      targetDir,
+      deploymentAttrs,
+      () => {}
+    );
+
+    const calls = childProcessMock.exec.mock.calls;
+    const npmCall = calls.find((call) => call.arguments[0].includes('npm ci'));
+    assert.ok(npmCall, 'Should run npm ci');
+  });
+
+  test('installDependencies skips if node_modules exists', async () => {
+    const fsMock = {
+      existsSync: mock.fn(),
+    };
+
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs': fsMock,
+        'node:child_process': childProcessMock,
+      }
+    );
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.includes('node_modules')) return true;
+      return false;
+    });
+
+    // clear mock calls
+    childProcessMock.exec.mock.resetCalls();
+
+    await sourceProcessor.installDependencies(
+      '/dir',
+      {
+        runtime: 'nodejs',
+        cmd: ['node', 'server.js'],
+        args: ['server.js'],
+        baseImage: 'node:22',
+      },
+      () => {}
+    );
+
+    assert.equal(childProcessMock.exec.mock.callCount(), 0);
+  });
+
+  test('installDependencies logs warn on failure but does not throw', async () => {
+    const fsMock = { existsSync: mock.fn(() => false) };
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs': fsMock,
+        'node:child_process': childProcessMock,
+      }
+    );
+
+    childProcessMock.exec.mock.mockImplementation((cmd, opts, callback) => {
+      if (typeof opts === 'function') callback = opts;
+      callback(new Error('npm failed'));
+    });
+
+    const consoleLogMock = mock.method(console, 'log');
+
+    await assert.doesNotReject(async () => {
+      await sourceProcessor.installDependencies('/dir', { runtime: 'nodejs' });
+    });
+
+    assert.equal(
+      consoleLogMock.mock.callCount(),
+      1,
+      'console.log should be called once'
+    );
+    const logArgs = consoleLogMock.mock.calls[0].arguments;
+    assert.ok(
+      logArgs[0].includes('Dependency installation failed: npm failed'),
+      'console.log should contain the error message'
+    );
+
+    consoleLogMock.mock.restore();
+  });
+
+  test('cleanupTempDirectory removes directory', async () => {
+    const fsMock = {
+      existsSync: mock.fn(() => true),
+    };
+
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs': fsMock,
+        'node:fs/promises': fspMock,
+      }
+    );
+
+    await sourceProcessor.cleanupTempDirectory('/temp/dir');
+
+    assert.equal(fspMock.rm.mock.callCount(), 1);
+    assert.deepEqual(fspMock.rm.mock.calls[0].arguments[0], '/temp/dir');
+  });
+
+  test('cleanupTempDirectory logs error on failure but does not throw', async () => {
+    const fsMock = { existsSync: mock.fn(() => true) };
+    // mock fsp.rm to throw
+    const fspMockThrow = {
+      rm: mock.fn(async () => {
+        throw new Error('rm failed');
+      }),
+    };
+
+    const consoleErrorMock = mock.method(console, 'error');
+
+    const sourceProcessor = await esmock(
+      '../../lib/deployment/source-processor.js',
+      {
+        'node:fs': fsMock,
+        'node:fs/promises': fspMockThrow,
+      }
+    );
+
+    await sourceProcessor.cleanupTempDirectory('/dir');
+
+    assert.equal(consoleErrorMock.mock.callCount(), 1);
+    assert.ok(
+      consoleErrorMock.mock.calls[0].arguments[1].message.includes('rm failed')
+    );
+
+    consoleErrorMock.mock.restore();
+  });
+});

package/test/local/test-utils.js

@@ -0,0 +1,51 @@
+/*
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * Waits for a specific string to appear in a stream's output.
+ * This is useful for synchronizing tests with asynchronous child processes,
+ * ensuring that a server or process has started and emitted an
+ * expected "ready" message before proceeding with test assertions.
+ *
+ * @param {ReadableStream} stream - The stream to listen to (e.g., process.stdout or process.stderr).
+ * @param {string} str - The string to wait for in the stream's output.
+ * @param {number} [timeoutMs=7000] - The maximum time in milliseconds to wait before rejecting.
+ * @returns {Promise<string>} A promise that resolves with the accumulated data
+ *   when the string is found, or rejects if the timeout is reached.
+ */
+export async function waitForString(stream, str, timeoutMs = 7000) {
+  let accumulatedData = '';
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      stream.removeListener('data', onData);
+      reject(
+        new Error(`waitForString timed out after ${timeoutMs}ms waiting for "${str}".
+Saw:
+${accumulatedData}`)
+      );
+    }, timeoutMs);
+
+    function onData(data) {
+      accumulatedData += data.toString();
+      if (accumulatedData.includes(str)) {
+        clearTimeout(timeout);
+        stream.removeListener('data', onData);
+        resolve(accumulatedData);
+      }
+    }
+    stream.on('data', onData);
+  });
+}