@google-cloud/cloud-run-mcp 1.9.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 () => {
@@ -50,7 +53,7 @@ describe('Deployment Helpers', () => {
     assert.equal(result.hasDockerfile, true);
   });
 
-  test('makeFileDeploymentMetadata correctly identifies Node.js project attributes', async () => {
+  test('makeFileDeploymentMetadata correctly identifies Node.js project', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -69,110 +72,75 @@ describe('Deployment Helpers', () => {
       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 () => {
+  test('canDeployWithoutBuild returns true for valid Node.js project', 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]);
+    const metadata = {
+      hasDockerfile: false,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+      },
+    };
 
-    // Should return empty deployment attrs
-    assert.equal(result.deploymentAttrs.runtime, undefined);
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), true);
   });
 
-  test('canDeployWithoutBuild returns true for valid Node.js zip deploy', async () => {
+  test('canDeployWithoutBuild returns false if Dockerfile exists', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
 
     const metadata = {
-      hasDockerfile: false,
+      hasDockerfile: true,
       deploymentAttrs: {
         runtime: 'nodejs',
-        cmd: ['node'],
-        args: ['index.js'],
-        baseImage: 'base-image',
       },
     };
 
-    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), true);
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
   });
 
-  test('canDeployWithoutBuild returns false if Dockerfile exists', async () => {
+  test('createDirectSourceDeploymentContainer creates correct object without envVars', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
 
-    const metadata = {
-      hasDockerfile: true,
+    const input = {
+      bucketName: 'test-bucket',
+      fileName: 'source.tar.gz',
       deploymentAttrs: {
-        runtime: 'nodejs',
         cmd: ['node'],
-        args: ['index.js'],
+        args: ['server.js'],
+        baseImage: 'gcr.io/google-appengine/nodejs',
       },
     };
 
-    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
+    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('createDirectSourceDeploymentContainer creates correct object', async () => {
+  test('createDirectSourceDeploymentContainer creates correct object with envVars', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -184,6 +152,10 @@ describe('Deployment Helpers', () => {
         cmd: ['node'],
         args: ['server.js'],
         baseImage: 'gcr.io/google-appengine/nodejs',
+        envVars: {
+          PORT: '8080',
+          NODE_ENV: 'production',
+        },
       },
     };
 
@@ -201,31 +173,106 @@ describe('Deployment Helpers', () => {
       },
       command: ['node'],
       args: ['server.js'],
+      env: [
+        { name: 'PORT', value: '8080' },
+        { name: 'NODE_ENV', value: 'production' },
+      ],
+    });
+  });
+
+  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 handles invalid package.json gracefully', async () => {
+  test('makeFileDeploymentMetadata correctly identifies compose file in folder', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
 
-    const folderPath = '/absolute/path/to/bad-json-app';
+    const folderPath = '/absolute/path/to/folder';
 
     fsMock.statSync.mock.mockImplementation(() => ({
       isDirectory: () => true,
     }));
 
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.endsWith('package.json')) return true;
+    fsMock.existsSync.mock.mockImplementation((filePath) => {
+      if (filePath.endsWith('compose.yaml')) 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);
+    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);
   });
 });