@google-cloud/cloud-run-mcp 1.6.0 → 1.8.0

package/test/local/deployment-helpers.test.js

@@ -0,0 +1,231 @@
+/*
+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';
+import { DEPLOYMENT_CONFIG } from '../../lib/deployment/constants.js';
+
+describe('Deployment Helpers', () => {
+  const fsMock = {
+    statSync: mock.fn(),
+    existsSync: mock.fn(),
+    readFileSync: mock.fn(),
+  };
+
+  test('makeFileDeploymentMetadata correctly identifies Dockerfile in folder', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/folder';
+
+    // Mock isFolder logic
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    // Mock Dockerfile check
+    fsMock.existsSync.mock.mockImplementation((filePath) => {
+      if (filePath.endsWith('Dockerfile') || filePath.endsWith('dockerfile'))
+        return true;
+      return false;
+    });
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.hasDockerfile, true);
+  });
+
+  test('makeFileDeploymentMetadata correctly identifies Node.js project attributes', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/node-app';
+
+    // Mock isFolder
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    // Mock existsSync
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('Dockerfile')) return false;
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    // Mock readFileSync for package.json
+    fsMock.readFileSync.mock.mockImplementation(() =>
+      JSON.stringify({
+        scripts: { start: 'node server.js' },
+      })
+    );
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.hasDockerfile, false);
+    assert.equal(result.deploymentAttrs.runtime, 'nodejs');
+    assert.deepEqual(result.deploymentAttrs.cmd, ['node']);
+    assert.deepEqual(result.deploymentAttrs.args, ['server.js']);
+  });
+
+  test('makeFileDeploymentMetadata ignores Node.js if engines.node is present', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/node-app-engines';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    fsMock.readFileSync.mock.mockImplementation(() =>
+      JSON.stringify({
+        scripts: { start: 'node server.js' },
+        engines: { node: '>=14' },
+      })
+    );
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.deploymentAttrs.runtime, undefined);
+  });
+
+  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/bad-json-app';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    // Mock readFileSync to return invalid JSON
+    fsMock.readFileSync.mock.mockImplementation(() => '{ invalid json }');
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    // Should return empty deployment attrs
+    assert.equal(result.deploymentAttrs.runtime, undefined);
+  });
+
+  test('canDeployWithoutBuild returns true for valid Node.js zip deploy', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const metadata = {
+      hasDockerfile: false,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+        cmd: ['node'],
+        args: ['index.js'],
+        baseImage: 'base-image',
+      },
+    };
+
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), true);
+  });
+
+  test('canDeployWithoutBuild returns false if Dockerfile exists', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const metadata = {
+      hasDockerfile: true,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+        cmd: ['node'],
+        args: ['index.js'],
+      },
+    };
+
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
+  });
+
+  test('createDirectSourceDeploymentContainer creates correct object', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const input = {
+      bucketName: 'test-bucket',
+      fileName: 'source.tar.gz',
+      deploymentAttrs: {
+        cmd: ['node'],
+        args: ['server.js'],
+        baseImage: 'gcr.io/google-appengine/nodejs',
+      },
+    };
+
+    const result =
+      deploymentHelpers.createDirectSourceDeploymentContainer(input);
+
+    assert.deepEqual(result, {
+      image: DEPLOYMENT_CONFIG.NO_BUILD_IMAGE_TYPE,
+      baseImageUri: 'gcr.io/google-appengine/nodejs',
+      sourceCode: {
+        cloudStorageSource: {
+          bucket: 'test-bucket',
+          object: 'source.tar.gz',
+        },
+      },
+      command: ['node'],
+      args: ['server.js'],
+    });
+  });
+
+  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/bad-json-app';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    // Mock readFileSync to return invalid JSON
+    fsMock.readFileSync.mock.mockImplementation(() => '{ invalid json }');
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    // Should return empty deployment attrs
+    assert.equal(result.deploymentAttrs.runtime, undefined);
+  });
+});

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

@@ -3,6 +3,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 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;
@@ -29,29 +30,32 @@ class MCPClient {
 describe('MCP Server in Streamble HTTP mode', () => {
   let client;
   let serverProcess;
-
-  before(async () => {
-    // Start MCP server as a child process
-    serverProcess = spawn('node', ['mcp-server.js'], {
-      cwd: process.cwd(),
-      env: { ...process.env, GCP_STDIO: 'false' },
-      stdio: 'inherit',
+  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');
     });
 
-    // Wait for server to start (better: poll the port, here we just wait)
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    client = new MCPClient('http-server');
-  });
-
-  after(async () => {
-    await client.cleanup();
-    if (serverProcess) {
-      serverProcess.kill();
-    }
-  });
+    after(async () => {
+      await client.cleanup();
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
 
-  test('should start an HTTP server', async () => {
-    await client.connectToServer('http://localhost:3000/mcp');
+    test('should start an HTTP server', async () => {
+      await client.connectToServer('http://localhost:3000/mcp');
+      assert.ok(stdout.includes(httpMsg));
+    });
   });
 });

package/test/local/mock-clients.js

@@ -0,0 +1,35 @@
+import { mock } from 'node:test';
+
+/**
+ * Creates a mock Cloud Build Client.
+ * @param {object} [overrides] - Optional overrides for methods.
+ * @returns {object} A mock Cloud Build Client.
+ */
+export function getMockCloudBuildClient(overrides = {}) {
+  return {
+    createBuild:
+      overrides.createBuild ||
+      mock.fn(() =>
+        Promise.resolve([
+          {
+            metadata: {
+              build: {
+                id: 'default-mock-build-id',
+              },
+            },
+          },
+        ])
+      ),
+    getBuild:
+      overrides.getBuild ||
+      mock.fn(() =>
+        Promise.resolve([
+          {
+            id: 'default-mock-build-id',
+            status: 'SUCCESS',
+          },
+        ])
+      ),
+    ...overrides,
+  };
+}

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();
+  });
+});