@google-cloud/cloud-run-mcp 1.9.0 → 1.11.0

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

@@ -75,171 +75,6 @@ describe('Source Processor', () => {
     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),

package/test/local/test-utils.js

@@ -1,19 +1,3 @@
-/*
-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,
@@ -22,11 +6,11 @@ limitations under the License.
  *
  * @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.
+ * @param {number} [timeoutMs=10000] - 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) {
+export async function waitForString(stream, str, timeoutMs = 10000) {
   let accumulatedData = '';
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {

package/test/local/tools.test.js

@@ -207,6 +207,7 @@ describe('registerTools', () => {
                 name: 'my-service',
                 uri: 'my-uri',
                 lastModifier: 'me',
+                updateTime: { seconds: '1735732800', nanos: 0 }, // 2025-01-01T12:00:00Z
               }),
           },
         }
@@ -223,11 +224,12 @@ describe('registerTools', () => {
         service: 'my-service',
       });
 
+      const expectedDate = new Date('2025-01-01T12:00:00Z').toUTCString();
       assert.deepStrictEqual(result, {
         content: [
           {
             type: 'text',
-            text: 'Name: my-service\nRegion: my-region\nProject: my-project\nURL: my-uri\nLast deployed by: me',
+            text: `Name: my-service\nRegion: my-region\nProject: my-project\nURL: my-uri\nConsole URL: https://console.cloud.google.com/run/detail/my-region/my-service?project=my-project\nLast deployed by: me\nLast deployed date: ${expectedDate}`,
           },
         ],
       });
@@ -324,6 +326,46 @@ describe('registerTools', () => {
         ],
       });
     });
+
+    it('should deploy local folder with ingress', async () => {
+      const server = {
+        registerTool: mock.fn(),
+      };
+      const deployMock = mock.fn(() => Promise.resolve({ uri: 'my-uri' }));
+
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/deployment/deployer.js': {
+            deploy: deployMock,
+          },
+        }
+      );
+
+      registerTools(server, {
+        gcpCredentialsAvailable: true,
+        ingress: 'INGRESS_TRAFFIC_INTERNAL_ONLY',
+      });
+
+      const handler = server.registerTool.mock.calls.find(
+        (call) => call.arguments[0] === 'deploy_local_folder'
+      ).arguments[2];
+      await handler(
+        {
+          project: 'my-project',
+          region: 'my-region',
+          service: 'my-service',
+          folderPath: '/my/folder',
+        },
+        { sendNotification: mock.fn() }
+      );
+
+      assert.strictEqual(
+        deployMock.mock.calls[0].arguments[0].ingress,
+        'INGRESS_TRAFFIC_INTERNAL_ONLY'
+      );
+    });
   });
 
   describe('deploy_file_contents', () => {

package/test/local/universal-maker.test.js

@@ -0,0 +1,157 @@
+/*
+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('Universal Maker', () => {
+  const fsMock = {
+    existsSync: mock.fn(),
+    mkdirSync: mock.fn(),
+    readFileSync: mock.fn(),
+    rmSync: mock.fn(),
+  };
+
+  const childProcessMock = {
+    exec: mock.fn(),
+  };
+
+  const osMock = {
+    homedir: () => '/home/user',
+    tmpdir: () => '/tmp',
+  };
+
+  const helpersMock = {
+    logAndProgress: mock.fn(),
+  };
+
+  const artifactsMock = {
+    ensureRepositoryDownloaded: mock.fn(),
+  };
+
+  test('runUniversalMaker skips download if binary exists and runs successfully', async () => {
+    fsMock.existsSync.mock.resetCalls();
+    fsMock.readFileSync.mock.resetCalls();
+    childProcessMock.exec.mock.resetCalls();
+    artifactsMock.ensureRepositoryDownloaded.mock.resetCalls();
+
+    // Mock binary exists and is up to date
+    artifactsMock.ensureRepositoryDownloaded.mock.mockImplementation(
+      () => '/home/user/.cloud-run-mcp/bin/universal_maker'
+    );
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.includes('build_output.json')) return true;
+      return false;
+    });
+
+    fsMock.readFileSync.mock.mockImplementation((p) => {
+      if (p.includes('build_output.json')) {
+        return JSON.stringify({
+          command: 'node',
+          args: ['index.js'],
+          runtime: 'nodejs20',
+          envVars: { DEBUG: 'true' },
+        });
+      }
+      return '';
+    });
+
+    const um = await esmock('../../lib/deployment/universal-maker.js', {
+      fs: fsMock,
+      child_process: childProcessMock,
+      os: osMock,
+      '../../lib/util/helpers.js': helpersMock,
+      '../../lib/util/artifacts.js': artifactsMock,
+    });
+
+    // Mock exec only for binary execution
+    childProcessMock.exec.mock.mockImplementation((cmd, cb) => {
+      cb(null, { stdout: '', stderr: '' });
+    });
+
+    // runUniversalMaker(appDir, accessToken, progressCallback)
+    const result = await um.runUniversalMaker(
+      '/app/dir',
+      'fake-token',
+      mock.fn()
+    );
+
+    assert.ok(result);
+    assert.equal(result.command, 'node');
+    assert.deepEqual(result.args, ['index.js']);
+    assert.equal(result.runtime, 'nodejs20');
+
+    // Verify ensureRepositoryDownloaded was called
+    assert.strictEqual(
+      artifactsMock.ensureRepositoryDownloaded.mock.callCount(),
+      1
+    );
+  });
+
+  test('runUniversalMaker behaves correctly when binary fails to download', async () => {
+    artifactsMock.ensureRepositoryDownloaded.mock.resetCalls();
+    artifactsMock.ensureRepositoryDownloaded.mock.mockImplementation(
+      () => null
+    );
+
+    const um = await esmock('../../lib/deployment/universal-maker.js', {
+      fs: fsMock,
+      child_process: childProcessMock,
+      os: osMock,
+      '../../lib/util/helpers.js': helpersMock,
+      '../../lib/util/artifacts.js': artifactsMock,
+    });
+
+    const result = await um.runUniversalMaker(
+      '/app/dir',
+      'fake-token',
+      mock.fn()
+    );
+
+    assert.equal(result, null);
+    assert.strictEqual(
+      artifactsMock.ensureRepositoryDownloaded.mock.callCount(),
+      1
+    );
+  });
+
+  test('runUniversalMaker returns null if binary not supported on platform', async () => {
+    // Save original platform
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+
+    try {
+      const um = await esmock('../../lib/deployment/universal-maker.js', {
+        fs: fsMock,
+        child_process: childProcessMock,
+        os: osMock,
+        '../../lib/util/helpers.js': helpersMock,
+        '../../lib/util/artifacts.js': artifactsMock,
+      });
+
+      const result = await um.runUniversalMaker(
+        '/app/dir',
+        'fake-token',
+        mock.fn()
+      );
+      assert.equal(result, null);
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    }
+  });
+});