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

package/test/local/deploy.test.js

@@ -0,0 +1,408 @@
+/*
+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 path from 'path';
+
+describe('Deploy Compose', () => {
+  const projectId = 'test-project';
+  const region = 'us-central1';
+  const accessToken = 'test-token';
+  const composeFilePath = '/abs/path/to/compose.yaml';
+  const files = [path.dirname(composeFilePath)];
+
+  test('successfully deploys a simple compose file with one source-built service', async () => {
+    // Setup mocks
+    const prepareSourceDirectoryMock = mock.fn(async () => '/tmp/temp-dir');
+    const getProjectNumberMock = mock.fn(async () => '123456789');
+    const downloadRunComposeMock = mock.fn(
+      async () => '/usr/local/bin/run-compose'
+    );
+    const resourceComposeMock = mock.fn(async () =>
+      JSON.stringify({
+        source_builds: {
+          web: { context: 'app' },
+        },
+      })
+    );
+    const translateComposeMock = mock.fn(async () =>
+      JSON.stringify({
+        services: {
+          web: 'web.yaml',
+        },
+      })
+    );
+    const triggerCloudBuildMock = mock.fn(async () => ({
+      results: {
+        images: [
+          {
+            name: 'us-central1-docker.pkg.dev/test-project/mcp-cloud-run-deployments/web:latest',
+          },
+        ],
+      },
+    }));
+    const ensureArtifactRegistryRepoExistsMock = mock.fn();
+    const ensureStorageBucketExistsMock = mock.fn(async () => ({}));
+    const uploadToStorageBucketMock = mock.fn();
+    const zipFilesMock = mock.fn(async () => Buffer.from('dummy zip content'));
+    const cleanupTempDirectoryMock = mock.fn();
+    const getRunV1ClientMock = mock.fn(async () => ({
+      namespaces: {
+        services: {
+          replaceService: mock.fn(async () => ({
+            data: { metadata: { name: 'web' } },
+          })),
+          create: mock.fn(),
+        },
+      },
+    }));
+    const fsMock = {
+      existsSync: mock.fn(() => true),
+      promises: {
+        mkdtemp: mock.fn(async () => '/tmp/random-dir'),
+        readFile: mock.fn(async () => 'name: web'),
+      },
+    };
+    const logAndProgressMock = mock.fn();
+
+    // Import with mocks
+    const { deployCompose } = await esmock('../../lib/deployment/deployer.js', {
+      '../../lib/deployment/source-processor.js': {
+        prepareSourceDirectory: prepareSourceDirectoryMock,
+        cleanupTempDirectory: cleanupTempDirectoryMock,
+      },
+      '../../lib/util/helpers.js': {
+        getProjectNumber: getProjectNumberMock,
+        logAndProgress: logAndProgressMock,
+      },
+      '../../lib/deployment/compose.js': {
+        runCompose: downloadRunComposeMock,
+        resourceCompose: resourceComposeMock,
+        translateCompose: translateComposeMock,
+        composeVolumes: mock.fn(async (resourcesConfig) => resourcesConfig),
+      },
+      '../../lib/cloud-api/build.js': {
+        triggerCloudBuild: triggerCloudBuildMock,
+        composeBuild: mock.fn(
+          async (resourcesConfig, token, pId, reg, fPath, cb) => {
+            for (const serviceName in resourcesConfig.source_builds) {
+              const imageUrl = `${reg}-docker.pkg.dev/${pId}/mcp-cloud-run-deployments/${serviceName}:latest`;
+              const buildResult = await triggerCloudBuildMock(
+                pId,
+                reg,
+                'bucket',
+                'blob',
+                'repo',
+                imageUrl,
+                true,
+                token,
+                cb
+              );
+              resourcesConfig.source_builds[serviceName].image_id =
+                buildResult.results.images[0].name;
+            }
+            return resourcesConfig;
+          }
+        ),
+      },
+      '../../lib/cloud-api/registry.js': {
+        ensureArtifactRegistryRepoExists: ensureArtifactRegistryRepoExistsMock,
+      },
+      '../../lib/util/archive.js': {
+        zipFiles: zipFilesMock,
+      },
+      '../../lib/cloud-api/storage.js': {
+        ensureStorageBucketExists: ensureStorageBucketExistsMock,
+        uploadToStorageBucket: uploadToStorageBucketMock,
+      },
+      '../../lib/clients.js': {
+        getRunV1Client: getRunV1ClientMock,
+      },
+      fs: fsMock,
+      path: path,
+    });
+
+    const result = await deployCompose({
+      projectId,
+      region,
+      files,
+      composeFilePath,
+      accessToken,
+      progressCallback: logAndProgressMock,
+    });
+
+    // Validations
+    assert.ok(result);
+    assert.equal(result.service, 'web');
+    assert.equal(result.uri, undefined); // In the mock, status.url is not provided
+    assert.equal(prepareSourceDirectoryMock.mock.callCount(), 1);
+    assert.equal(resourceComposeMock.mock.callCount(), 1);
+    assert.equal(translateComposeMock.mock.callCount(), 1);
+    assert.equal(triggerCloudBuildMock.mock.callCount(), 1);
+    assert.equal(cleanupTempDirectoryMock.mock.callCount(), 1);
+
+    // Verify triggerCloudBuild was called with correctly updated image tag
+    const buildCall = triggerCloudBuildMock.mock.calls[0];
+    assert.equal(
+      buildCall.arguments[5],
+      'us-central1-docker.pkg.dev/test-project/mcp-cloud-run-deployments/web:latest'
+    );
+  });
+
+  test('failure in prepareSourceDirectory triggers cleanup and rethrows', async () => {
+    const error = new Error('Preparation failed');
+    const prepareSourceDirectoryMock = mock.fn(async () => {
+      throw error;
+    });
+    const logAndProgressMock = mock.fn();
+    const cleanupTempDirectoryMock = mock.fn();
+
+    const { deployCompose } = await esmock('../../lib/deployment/deployer.js', {
+      '../../lib/deployment/source-processor.js': {
+        prepareSourceDirectory: prepareSourceDirectoryMock,
+        cleanupTempDirectory: cleanupTempDirectoryMock,
+      },
+      '../../lib/util/helpers.js': {
+        logAndProgress: logAndProgressMock,
+      },
+    });
+
+    await assert.rejects(
+      deployCompose({
+        projectId,
+        region,
+        files,
+        composeFilePath,
+        accessToken,
+        progressCallback: logAndProgressMock,
+      }),
+      error
+    );
+
+    assert.equal(
+      logAndProgressMock.mock.calls.some(
+        (call) => call.arguments[2] === 'error'
+      ),
+      true
+    );
+  });
+
+  test('calls composeSecrets during deployment', async () => {
+    const composeSecretsMock = mock.fn(
+      async (resourcesConfig) => resourcesConfig
+    );
+    const prepareSourceDirectoryMock = mock.fn(async () => '/tmp/temp-dir');
+    const downloadRunComposeMock = mock.fn(async () => '/bin/run-compose');
+    const resourceComposeMock = mock.fn(async () => JSON.stringify({}));
+    const translateComposeMock = mock.fn(async () =>
+      JSON.stringify({ services: {} })
+    );
+    const getProjectNumberMock = mock.fn(async () => '123456');
+    const cleanupTempDirectoryMock = mock.fn();
+
+    const { deployCompose } = await esmock('../../lib/deployment/deployer.js', {
+      '../../lib/deployment/source-processor.js': {
+        prepareSourceDirectory: prepareSourceDirectoryMock,
+        cleanupTempDirectory: cleanupTempDirectoryMock,
+      },
+      '../../lib/util/helpers.js': {
+        getProjectNumber: getProjectNumberMock,
+        logAndProgress: mock.fn(),
+      },
+      '../../lib/deployment/compose.js': {
+        runCompose: downloadRunComposeMock,
+        resourceCompose: resourceComposeMock,
+        translateCompose: translateComposeMock,
+        composeVolumes: mock.fn(async (resourcesConfig) => resourcesConfig),
+        composeSecrets: composeSecretsMock,
+      },
+      '../../lib/clients.js': {
+        getRunV1Client: mock.fn(async () => ({ namespaces: { services: {} } })),
+      },
+      fs: {
+        promises: {
+          readFile: mock.fn(async () => 'name: web'),
+        },
+      },
+      path: path,
+    });
+
+    await deployCompose({
+      projectId,
+      region,
+      files,
+      composeFilePath,
+      accessToken,
+      progressCallback: mock.fn(),
+    });
+
+    assert.strictEqual(composeSecretsMock.mock.callCount(), 1);
+  });
+
+  test('successfully deploys models and services in correct order', async () => {
+    const prepareSourceDirectoryMock = mock.fn(async () => '/tmp/temp-dir');
+    const getProjectNumberMock = mock.fn(async () => '123456');
+    const downloadRunComposeMock = mock.fn(async () => '/bin/run-compose');
+    const resourceComposeMock = mock.fn(async () => JSON.stringify({}));
+    const translateComposeMock = mock.fn(async () =>
+      JSON.stringify({
+        models: { 'my-model': 'model.yaml' },
+        services: { 'my-app': 'app.yaml' },
+      })
+    );
+
+    const deployedServices = [];
+    const replaceServiceMock = mock.fn(async (params) => {
+      // Extract service name from namespaces/{p}/services/{s}
+      const serviceName = params.name.split('/').pop();
+      deployedServices.push(serviceName);
+      return { data: { status: { url: `https://${serviceName}.a.run.app` } } };
+    });
+
+    const getRunV1ClientMock = mock.fn(async () => ({
+      namespaces: {
+        services: {
+          replaceService: replaceServiceMock,
+        },
+      },
+    }));
+
+    const { deployCompose } = await esmock('../../lib/deployment/deployer.js', {
+      '../../lib/deployment/source-processor.js': {
+        prepareSourceDirectory: prepareSourceDirectoryMock,
+        cleanupTempDirectory: mock.fn(),
+      },
+      '../../lib/util/helpers.js': {
+        getProjectNumber: getProjectNumberMock,
+        logAndProgress: mock.fn(),
+      },
+      '../../lib/deployment/compose.js': {
+        runCompose: downloadRunComposeMock,
+        resourceCompose: resourceComposeMock,
+        translateCompose: translateComposeMock,
+        composeVolumes: mock.fn(async (resourcesConfig) => resourcesConfig),
+        composeSecrets: mock.fn(async (resourcesConfig) => resourcesConfig),
+      },
+      '../../lib/clients.js': {
+        getRunV1Client: getRunV1ClientMock,
+      },
+      fs: {
+        promises: {
+          readFile: mock.fn(async () => 'name: dummy'),
+        },
+      },
+      path: path,
+    });
+
+    const result = await deployCompose({
+      projectId,
+      region,
+      files,
+      composeFilePath,
+      accessToken,
+      progressCallback: mock.fn(),
+    });
+
+    assert.ok(result);
+    assert.strictEqual(result.service, 'my-app');
+    assert.strictEqual(result.uri, 'https://my-app.a.run.app');
+    assert.strictEqual(deployedServices.length, 2);
+    // Verify order: models first
+    assert.strictEqual(deployedServices[0], 'my-model');
+    assert.strictEqual(deployedServices[1], 'my-app');
+  });
+
+  test('sanitizes service names with underscores', async () => {
+    const rawServiceName = 'ai-model-test_web';
+    const sanitizedName = 'ai-model-test-web';
+
+    const prepareSourceDirectoryMock = mock.fn(async () => '/tmp/temp-dir');
+    const getProjectNumberMock = mock.fn(async () => '123456');
+    const downloadRunComposeMock = mock.fn(async () => '/bin/run-compose');
+    const translateComposeMock = mock.fn(async () =>
+      JSON.stringify({
+        services: { [rawServiceName]: 'web.yaml' },
+      })
+    );
+
+    const replaceServiceMock = mock.fn(async (params) => {
+      return { data: { metadata: { name: params.name.split('/').pop() } } };
+    });
+
+    const { deployCompose } = await esmock('../../lib/deployment/deployer.js', {
+      '../../lib/deployment/source-processor.js': {
+        prepareSourceDirectory: prepareSourceDirectoryMock,
+        cleanupTempDirectory: mock.fn(),
+      },
+      '../../lib/util/helpers.js': {
+        getProjectNumber: getProjectNumberMock,
+        logAndProgress: mock.fn(),
+        sanitizeCloudRunServiceName: (name) =>
+          name
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '-')
+            .replace(/^-+|-+$/g, ''),
+      },
+      '../../lib/deployment/compose.js': {
+        runCompose: downloadRunComposeMock,
+        resourceCompose: mock.fn(async () => JSON.stringify({})),
+        translateCompose: translateComposeMock,
+        composeVolumes: mock.fn(async (resourcesConfig) => resourcesConfig),
+        composeSecrets: mock.fn(async (resourcesConfig) => resourcesConfig),
+      },
+      '../../lib/cloud-api/build.js': {
+        composeBuild: mock.fn(async (rc) => rc),
+      },
+      '../../lib/clients.js': {
+        getRunV1Client: mock.fn(async () => ({
+          namespaces: { services: { replaceService: replaceServiceMock } },
+        })),
+      },
+      fs: {
+        promises: {
+          readFile: mock.fn(async () => 'metadata:\n  name: ai-model-test_web'),
+        },
+      },
+      path: path,
+    });
+
+    await deployCompose({
+      projectId,
+      region,
+      files,
+      composeFilePath,
+      accessToken,
+      progressCallback: mock.fn(),
+    });
+
+    assert.strictEqual(replaceServiceMock.mock.callCount(), 1);
+    const call = replaceServiceMock.mock.calls[0];
+
+    // Verify name in URL was sanitized
+    assert.strictEqual(
+      call.arguments[0].name,
+      `namespaces/${projectId}/services/${sanitizedName}`
+    );
+
+    // Verify name in requestBody metadata was sanitized
+    assert.strictEqual(
+      call.arguments[0].requestBody.metadata.name,
+      sanitizedName
+    );
+  });
+});

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

@@ -23,7 +23,10 @@ describe('Deployment Helpers', () => {
   const fsMock = {
     statSync: mock.fn(),
     existsSync: mock.fn(),
-    readFileSync: mock.fn(),
+    promises: {
+      readdir: mock.fn(),
+      readFile: mock.fn(),
+    },
   };
 
   test('makeFileDeploymentMetadata correctly identifies Dockerfile in folder', async () => {
@@ -176,4 +179,100 @@ describe('Deployment Helpers', () => {
       ],
     });
   });
+
+  test('uploadDirectory recursively uploads files', async () => {
+    const uploadToStorageBucketMock = mock.fn(async () => ({}));
+    const readFileMock = mock.fn(async () => Buffer.from('content'));
+
+    // Create a setup for each call to differentiate directory depth
+    fsMock.promises.readdir.mock.resetCalls();
+    fsMock.promises.readdir.mock.mockImplementation(async (p) => {
+      if (p.endsWith('subdir')) {
+        return [{ name: 'file2.txt', isDirectory: () => false }];
+      }
+      return [
+        { name: 'file1.txt', isDirectory: () => false },
+        { name: 'subdir', isDirectory: () => true },
+      ];
+    });
+
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: {
+        ...fsMock,
+        promises: {
+          ...fsMock.promises,
+          readFile: readFileMock,
+        },
+        default: {
+          ...fsMock,
+          promises: {
+            ...fsMock.promises,
+            readFile: readFileMock,
+          },
+        },
+      },
+      '../../lib/cloud-api/storage.js': {
+        uploadToStorageBucket: uploadToStorageBucketMock,
+      },
+    });
+
+    const bucket = { name: 'test-bucket' };
+    const localPath = '/local/path';
+    const gcsPrefix = 'prefix';
+    const progressCallback = mock.fn();
+
+    await deploymentHelpers.uploadDirectory(
+      bucket,
+      localPath,
+      gcsPrefix,
+      progressCallback
+    );
+
+    assert.strictEqual(uploadToStorageBucketMock.mock.callCount(), 2);
+
+    // Verify first upload (root level)
+    const call1 = uploadToStorageBucketMock.mock.calls[0];
+    assert.ok(call1.arguments[2].endsWith('prefix/file1.txt'));
+
+    // Verify second upload (subdir level)
+    const call2 = uploadToStorageBucketMock.mock.calls[1];
+    assert.ok(call2.arguments[2].endsWith('prefix/subdir/file2.txt'));
+  });
+
+  test('makeFileDeploymentMetadata correctly identifies compose file in folder', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/folder';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((filePath) => {
+      if (filePath.endsWith('compose.yaml')) return true;
+      return false;
+    });
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.ok(result.composeFilePath.endsWith('compose.yaml'));
+  });
+
+  test('makeFileDeploymentMetadata returns null for composeFilePath if no compose file exists', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const files = ['Dockerfile', 'index.js'];
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => false,
+    }));
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata(files);
+
+    assert.strictEqual(result.composeFilePath, null);
+  });
 });

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